目录
什么是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？
- 快速开发：Spring Boot提供了快速构建和部署Spring应用的能力。
- 开箱即用：内嵌了Tomcat、Jetty等服务器，无需部署WAR文件。
- 自动配置：根据添加的依赖自动配置Spring应用，减少手动配置。
- 无代码生成：不需要生成额外的XML或Java配置代码。
- 生产就绪：提供了监控和管理应用的工具，如指标、健康检查等。
3.Spring Boot的核心概念
- Spring Boot Starter：提供项目所需的依赖集合，简化依赖管理。
- Spring Boot Auto-Configuration：自动配置Spring和第三方库，无需手动配置。
- Spring Boot Actuator：提供应用监控和管理的端点。
- Spring Boot CLI：命令行工具，用于快速开发和测试Spring应用。
- 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应用开发的不二选择。
