当前位置： 首页 > article >正文

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

article 2024/9/20 17:53:09

目录

什么是Spring Boot？

为什么选择Spring Boot？

Spring Boot的核心概念

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

步骤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应用开发的不二选择。


http://www.kler.cn/news/305763.html

相关文章：

  • 远程访问电脑共享文件
  • 【Arduino】BNO085 姿态的 3D模型 展示方法（映射到 Unity）
  • Mybatis通用接口-基于Provider
  • 一维稳态与非稳态导热的详细分析
  • 力扣100题——栈和堆
  • 设计模式 装饰模式（Decorator Pattern）
  • 讨论人机交互研究中大语言模型的整合与伦理问题
  • Mysql----索引与事务
  • NLP基础及其代码-BERT系列
  • Ubuntu 24.04 配置 nginx + php-fpm
  • 异常冲突行为和危险识别系统源码分享
  • Rust使用dotenvy读取环境变量
  • 网络通信流程
  • 树和二叉树基本术语、性质
  • 劳特巴赫ICD调试器CMM调用烧录框架固件研究之C语言版本
  • GitHub每日最火火火项目（9.15）
  • 影刀RPA实战：网页爬虫之CSDN博文作品数据
  • 基于C#+SQL Server2008 开发三层架构（CS界面）图书管理系统
  • SQLmap使用请求包进行sql爆破
  • 鹏哥C语言自定义笔记重点(67-)
  • MySQL练手题--公司和部门平均工资比较（困难）
  • 【前端UI框架】VUE ElementUI 离线文档 可不联网打开
  • 后端面试经典问题汇总
  • MATLAB中的函数编写有哪些最佳实践
  • Python(PyTorch)和MATLAB及Rust和C++结构相似度指数测量导图
  • JS的事件以及常见事件的绑定
  • Win电脑使用Ollama与Open Web UI搭建本地大语言模型运行工具
  • Go 中 Gin 框架的使用指南
  • GIS 中的 3D 分析
  • 数据结构基础详解:哈希表【C语言代码实践篇】开放地址法__拉链法_哈希表的创建_增删查操作详解