Spring Boot：现代化Java应用开发的艺术

目录

[什么是Spring Boot？](#什么是Spring Boot？)

[为什么选择Spring Boot？](#为什么选择Spring Boot？)

[Spring Boot的核心概念](#Spring Boot的核心概念)

[详细步骤：创建一个Spring Boot应用](#详细步骤：创建一个Spring Boot应用)

[步骤1：使用Spring Initializr创建项目](#步骤1：使用Spring Initializr创建项目)

步骤2：解压并导入项目

步骤3：构建和配置项目

pom.xml（Maven项目）

application.yml（配置文件）

步骤4：创建实体和仓库

User.java（实体类）

步骤5：创建映射方法

Mapper,BaseMapper

步骤6：创建服务类

UserService.java（服务类）

步骤7：创建映射文件

EmpDaoMapperInfo.xml

步骤8：创建控制类

Controller

步骤9：运行应用

步骤10：测试应用

总结

---

1.什么是Spring Boot？

Spring Boot是Pivotal团队（现为VMware的一部分）提供的一套快速开发Spring应用的脚手架。它基于Spring框架，通过提供一系列的"Starters"和自动配置，简化了Spring应用的初始搭建和开发过程。Spring Boot的目标是让你尽可能快地运行和部署Spring应用。

2.为什么选择Spring Boot？

1. 快速开发：Spring Boot提供了快速构建和部署Spring应用的能力。
2. 开箱即用：内嵌了Tomcat、Jetty等服务器，无需部署WAR文件。
3. 自动配置：根据添加的依赖自动配置Spring应用，减少手动配置。
4. 无代码生成：不需要生成额外的XML或Java配置代码。
5. 生产就绪：提供了监控和管理应用的工具，如指标、健康检查等。

3.Spring Boot的核心概念

1. Spring Boot Starter：提供项目所需的依赖集合，简化依赖管理。
2. Spring Boot Auto-Configuration：自动配置Spring和第三方库，无需手动配置。
3. Spring Boot Actuator：提供应用监控和管理的端点。
4. Spring Boot CLI：命令行工具，用于快速开发和测试Spring应用。
5. Spring Initializr：在线工具，用于快速生成Spring Boot项目结构。

4.详细步骤：创建一个Spring Boot应用

步骤1：使用Spring Initializr创建项目

访问Spring Initializr，选择以下选项：

• Project: Maven Project 或 Gradle Project
• Language: Java
• Spring Boot版本：选择最新的稳定版本
• Group: com.example
• Artifact: demo
• Dependencies: Spring Web, Spring Data JPA, H2 Database

点击"Generate"按钮，下载生成的项目压缩包。

步骤2：解压并导入项目

将下载的压缩包解压，并使用IDE（如IntelliJ IDEA或Eclipse）导入项目。

步骤3：构建和配置项目

pom.xml（Maven项目）

确保pom.xml文件中包含了以下依赖：

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

        <!--spring-mybatis整合包-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.3</version>
        </dependency>

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

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



        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </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>

application.yml（配置文件）

在src/main/resources目录下，编辑application.properties文件，添加数据库配置：

#DB Configuration:
spring:
  #连接池配置
  datasource:
    type: com.alibaba.druid.pool.DruidDataSource
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/schoolbase?useSSL=false&useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
      username: root
      password: 123456
      initial-size: 1                     #连接池初始大小
      max-active: 20                      #连接池中最大的活跃连接数
      min-idle: 1                         #连接池中最小的活跃连接数
      max-wait: 60000                     #配置获取连接等待超时的时间
      pool-prepared-statements: true    #打开PSCache，并且指定每个连接上PSCache的大小
      max-pool-prepared-statement-per-connection-size: 20
      validation-query: SELECT 1 FROM DUAL
      validation-query-timeout: 30000
      test-on-borrow: false             #是否在获得连接后检测其可用性
      test-on-return: false             #是否在连接放回连接池后检测其可用性
      test-while-idle: true             #是否在连接空闲一段时间后检测其可用性


#mybatis配置
mybatis:
  mapper-locations: classpath:mapper/*MapperInfo.xml
  type-aliases-package: com.fs.pojo
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

步骤4：创建实体和仓库

User.java（实体类）

package com.fs.pojo;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.ToString;
import org.springframework.format.annotation.DateTimeFormat;

import java.util.Date;

@Data
@AllArgsConstructor
@NoArgsConstructor
@ToString
public class Emp {
    private Integer empno;
    private String ename;
    private String pass;
    private String job;
    private Integer deptno;
    private Integer mgr;

    @DateTimeFormat(pattern = "yyyy-MM-dd") //提交请求的日期转换
    @JsonFormat(pattern = "yyyy-MM-dd",timezone = "GMT+8") //响应json转换
    private Date hiredate;
    private Double sal;
}

步骤5：创建映射方法

Mapper,BaseMapper

这是基础映射接口：

package com.fs.mapper;

import java.io.Serializable;
import java.util.List;

//基础映射接口，公共的方法

public interface BaseMapper<T> {
    /**
     * 插入一条记录
     * @param entity
     * 实体对象
     * @return int
     */
    Integer insert(T entity) throws  Exception;

    /**
     * 根据 ID 修改
     * @param entity
     * 实体对象
     * @return int
     */
    Integer update(T entity)throws  Exception;

    /**
     * 根据 ID 删除
     * @param id
     * 主键ID
     * @return int
     */
    Integer deleteById(Serializable id) throws  Exception;

    /**
     * 根据 ID 查询
     * @param id
     * 主键ID
     * @return T
     */
    T selectById(Serializable id) throws  Exception;

    /**
     * 查询所有
     * @return List<T>
     */
    List<T> selectAll() throws  Exception;


}

这是自己的Mapper直接继承BaseMapper，再写一些额外的方法

package com.fs.mapper;

import com.fs.pojo.Emp;
import com.fs.vo.Condition;
import org.apache.ibatis.annotations.Mapper;
import org.springframework.stereotype.Repository;

import java.util.List;

@Repository
@Mapper  //接口实现映射代理
public interface EmployeeMapper extends BaseMapper<Emp>{


    /**
     * 登录功能
     * @param employeeModel 密码 用户名
     * @return 用户对象
     */
    Emp login(Emp employeeModel);

    /**
     * 根据条件查询
     * @param condition 条件对象
     * @return 结果集合
     */
    List<Emp> selectByCondition(Condition condition);


}

步骤6：创建服务类

UserService.java（服务类）

服务类接口：

package com.fs.service;

import com.fs.pojo.Emp;
import com.fs.vo.Condition;


import java.util.List;

public interface EmpService {

    int addEmp(Emp employeeModel) throws Exception;

    //int updateEmp(EmployeeModel employeeModel) throws Exception;

    int delete(int empno) throws Exception;

    List<Emp> queryEmps() throws Exception;

    Emp login(Emp employeeModel);

    //条件查询
    List<Emp> queryByCondition(Condition condition);
}

实现类：

package com.fs.service.impl;

import com.fs.mapper.EmployeeMapper;
import com.fs.pojo.Emp;
import com.fs.service.EmpService;
import com.fs.vo.Condition;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class EmpServiceImpl implements EmpService {

    //注入映射代理
    @Resource
    private EmployeeMapper employeeMapper;
    @Override
    public int addEmp(Emp employeeModel) throws Exception {

        return employeeMapper.insert(employeeModel);
    }

    @Override
    public int delete(int empno) throws Exception {
        return employeeMapper.deleteById(empno);
    }

    @Override
    public List<Emp> queryEmps() throws Exception {
        return employeeMapper.selectAll();
    }

    @Override
    public Emp login(Emp employeeModel) {
        return employeeMapper.login(employeeModel);
    }

    @Override
    public List<Emp> queryByCondition(Condition condition) {
        return employeeMapper.selectByCondition(condition);
    }
}

步骤7：创建映射文件

EmpDaoMapperInfo.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.fs.mapper.EmployeeMapper">


    <select id="selectAll" resultMap="empmap">
        select * from emp
    </select>

    <select id="login" parameterType="Emp" resultMap="empmap">
        select * from emp where
        ename=#{ename} and pass=#{pass}
    </select>

    <delete id="deleteById" parameterType="int">
        delete from emp where empno = #{empno}
    </delete>




    <select id="selectById" parameterType="java.lang.Integer" resultMap="empmap">
        select * from emp where empno=#{no}
    </select>


    <insert id="insert" parameterType="Emp">
        insert into emp (empno,ename,job,sal,pass,hiredate)
        values (#{empno},#{ename},#{job},#{sal},#{pass},#{hiredate})
    </insert>

    <select id="selectByCondition" parameterType="com.fs.vo.Condition"
            resultMap="empmap">
        select * from emp

    </select>



    
     <resultMap id="empmap" type="Emp">
         <id column="empno" property="empno"></id>
         <result column="ename" property="ename"></result>
         <result column="job" property="job"></result>
         <result column="sal" property="sal"></result>
         <result column="pass" property="pass"></result>
         <result column="hiredate" property="hiredate"></result>
     </resultMap>

</mapper>

步骤8：创建控制类

Controller

package com.fs.controller;

import com.fs.pojo.Dept;
import com.fs.pojo.Emp;
import com.fs.service.DeptService;
import com.fs.service.EmpService;
import com.fs.vo.CommonResultVo;
import com.fs.vo.Condition;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@RestController
//@RequestMapping("/emp")
public class EmyController {

    @Resource
    private EmpService empService;

    @Resource
    private DeptService deptService;


    @RequestMapping("/test")
    public String empTest(){

        return "test";
    }

    @PostMapping("/add")
    public Map add(Emp employeeModel) throws Exception {
        int i = empService.addEmp(employeeModel);

        Map map = new HashMap();
        map.put("code",200);
        map.put("msg","插入成功");
        //转换成json对象
        return map;
    }

    @RequestMapping("/query")
    public Map queryAll() throws Exception {
        //查询所有数据
        List<Emp> employeeModels = empService.queryEmps();

        Map map = new HashMap();
        map.put("code",200);
        map.put("msg","查询成功");
        map.put("data",employeeModels);
        map.put("totals",employeeModels.size());

        return map;
    }

    @RequestMapping("/querybyconition")
    public CommonResultVo<Emp> queryByCondition(Condition condition){
        List<Emp> employeeModels = empService.queryByCondition(condition);

        //返回统一的公共响应类型对象
        CommonResultVo<Emp> commonResultVo = new CommonResultVo();
        commonResultVo.setCode(200);
        commonResultVo.setMsg("多条件查询成功");
        commonResultVo.setList(employeeModels);
        commonResultVo.setTotal(employeeModels.size());

        return commonResultVo;
    }

    //@RequestMapping("/login")
    @PostMapping("/login")
    public CommonResultVo login(Emp employeeModel){
        Emp employee = empService.login(employeeModel);

        CommonResultVo commonResultVo = new CommonResultVo();

        if (employee!= null) {
            commonResultVo.setCode(200);
            commonResultVo.setMsg("登录成功");
            commonResultVo.setData(employee);
        }else{
            commonResultVo.setCode(500);
            commonResultVo.setMsg("登录失败");
        }

        return commonResultVo;
    }



    @RequestMapping("/queryDept")
    public CommonResultVo getAllDept() throws Exception {
        List<Dept> depts = deptService.queryAll();
        CommonResultVo commonResultVo = new CommonResultVo();
        commonResultVo.setCode(200);
        commonResultVo.setMsg("部门查询成功");
        commonResultVo.setList(depts);

        return  commonResultVo;
    }


}

温馨提示：当然你还可以写一些前端页面用于展示

步骤9：运行应用

运行主应用类DemoApplication，应用将启动并监听默认的8080端口。

步骤10：测试应用

使用Postman或任何HTTP客户端工具，发送请求到http://localhost:8080/users来测试你的应用。

• GET /users：获取所有用户列表。
• POST /users：创建一个新用户。

5.总结

Spring Boot通过提供一系列的Starters、自动配置和简化的部署流程，极大地提高了Java应用的开发效率。通过上述步骤，你可以快速搭建一个具有RESTful API的Spring Boot应用，并使用Spring Data JPA进行数据持久化。Spring Boot的这些特性使得它成为现代Java应用开发的不二选择。