SpringBoot手把手实战入门

已于 2023-01-10 23:12:54 修改
阅读量201 收藏 2
点赞数 1
分类专栏： Evanpatchouli的知识星球 Evanpatchouli的项目 文章标签： spring boot 后端 java github
于 2023-01-10 19:07:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51810668/article/details/128592838
版权

【我的2022下半年回顾-1】-SpringBoot

前言

       2022过去了，迎来崭新的一年，在过去的半年里，我不仅在课内，还在课外通过各种方式了解和学习到了不少新的语言、框架、技术等等。平时急于产出和学习，没能好好的整理所学，遂在这个寒假，从这篇文章开始，以一系列文章作为对这段时间所学所作进行一个系统性回顾整理的过程，希望给自己查漏补缺，并能给一些正在或将要学习其中某些内容的朋友们一点启发。
       这篇文章，将浅层概述Springboot的原理，配置，架构等，一步步讲解，采用常规的java技术栈，手把手完成一个简易的个人信息系统后端（注册、登录、改密、增和改个人信息）

导航

       发文顺序从上到下，顺序大致按我接触它们的时间点排的，可能个别文章会提早或延后

  • Springboot【√】
  • Java EE/ Jakata EE
  • 网络安全框架 (Java)
    • Spring Security
    • Sa-Token
  • Vue.js
  • Web UI
  • Mybatis
  • Auto.js
  • 浏览器3D引擎(轻量级): Three.js
  • Uniapp / Unicloud 开发
  • 微信小程序开发
  • 前端深度学习引擎: Tensorflow.js
  • 其他
    • 利用Git管理源代码
    • 利用maven管理java项目
    • 利用npm管理项目
    • Node.js配置和管理
    • Sqlite: 内存中的轻数据库
    • 软件过程和项目管理浅谈
    • 打造自己的前端组件库
    • 软件测试工具
    • 文档撰写利器

正文

Spring是什么？SpringBoot呢？

不作赘述，简单了解一下：
苦于早期Javaee EJB的笨重繁琐，Spring框架诞生了，便捷的注解等特性使java应用的开发难度大大降低，Spring迅速风靡全球。SpringBoot是建立在Spring基础上的一个开源框架，提供了默认的Spring环境，对Spring的配置和开发进行了再一步简化，使得程序员更专注于业务代码，渐渐成为java微服务开发的利器之一。

创建SpringBoot项目

在创建项目之前，建议在你的开发环境中安装java8+和maven，并选择一款适合你的Java IDE，并为你的IDE配置好jdk和maven。我选择的是Intellij IDEA和VsCode(偶尔)，VsCode须安装Java Extension Pack和Spring Boot Extension Pack。

maven命令行创建（不推荐）

  1. cmd下cd进入你准备存放项目的目录（我更喜欢在资源管理器地址栏直接cmd 😃）
  2. mvn archetype:generate -DgroupId=com.evanpatchouli.demo -DartifactId=SpringBootDemo_mvn -DinteractiveMode=false
    你将会得到这样的目录↓（-DartifactId：项目文件名）mvn第一步结果
  3. 接着就是在pom.xml加入各种springboot依赖使这个基础的java项目变成springboot项目
  4. 这样就完成了，是不是很繁琐，最后开发的时候还是要回到IDE，那直接用IDE创建项目何乐而不为呢？所以不推荐

VsCode（推荐）

VsCode好处在于，美观、易用、免费和轻量（没加装太多插件的前提下）

  1. Ctrl + Shift + P > Spring Initializr > 选择Maven
    Spring初始化
  2. 选择SpringBoot版本，如果你需要使用新出的SpringBoot 3.x，请确保你的jdk17+
  3. 选择语言，Java > GroupId > Artifact Id > jdk版本:你使用的
    注意GroupId和Artifact Id和上面maven不同，GroupId对应com.evanpatchouli，ArifactId对应demo，包着项目的目录会在最后一步让你选择
  4. 接着这步是提前配备一些工具，有不少都是常用的，可以按需选择。我准备在示例里写个常规的web项目，选择了以下这5个，支持了SpringMVC和MySql，并选用其余的快速开发
    选择工具
  5. 到这里，就创建成功了！你将会得到这样的目录↓
    在这里插入图片描述
  6. 注意了，还没完，打开终端：mvn help:system，看看有没有报错。比如我在第2步选择了springboot 2.7.8，但实际上我的maven镜像是腾讯的，他们仓库里面貌似没有这么高的版本（你问我那为啥还选2.7.8？最新的Spring Initializr给我的选项最低就是它了…），我就把pom.xml里面的换成了2.3.7 RELEASE，或者你去maven官方仓库下对应版本的jar放到本地仓库也行。接着又爆了个错:Failed to calculate Effective POM，我才发现vscode的maven配置里settings.xml的s漏打了，所以请务必确保确保你的环境配置正确。
  7. 尝试运行一下，先进行一些配置，配置端口和mysql，因为我启用了mysql
# 应用名称
spring.application.name=demo
# 应用服务 WEB 访问端口
server.port=8080

# MySQL数据库驱动：
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# 数据源名称
spring.datasource.name=defaultDataSource
# 数据库连接地址
spring.datasource.url=jdbc:mysql://localhost:3306/speingdemo?useUnicode=true&characterEncoding=utf-8&serverTimezone=GMT
# 数据库用户名&密码：
spring.datasource.username=root
spring.datasource.password=root

不出意外的话，显示Started DemoApplication in 9.041 seconds (JVM running for 9.802)就成功了

IntelliJ IDEA（推荐）

在Java开发上，IDEA是一款极好的IDE，我通常会选择IDEA来开发SpringBoot
需要注意的是，版本较旧的IDEA可能不支持较新版本的SpringBoot，比如我现在用的是2019的，在发布SpringBoot 3.0 那天我捣鼓了半天才意识到我的IDEA不支持最新版的Spring

  1. 新建项目 > Spring Initializr ，如果default的你打不开，可以换个网络、看看一下idea的proxy、还有maven镜像路径是不是https的，或者可以使用阿里的：https://start.aliyun.com
    idea初始化项目
  2. 剩余步骤和vscode里介绍的差不离，记得Type选maven，不要选maven.pom
  3. 创建完成后，等它加载依赖，初次加载依赖可能要不少时间，耐心等待，等上方工具栏这玩意出来，就说明OK了，可以运行
    SpringInit_success_idea

Initializr 网页创建

SpringMVC是什么？

  • 概念： MVC，全称Model-View-Controller（模型、视图、控制器），我摆一张springmvcspringmvc
    前端（携带数据）请求指定路径的接口（Controller），接口接受数据，进行业务处理，业务代码操作Mapper接口操作数据库，将结果最终返回到Controller上，对业务结果做一个结构化的封装再返回给前端，前端拿到响应结果后，在页面上进行渲染。

手写springmvc：简易账号系统

示例项目将采用前后端分离（Vue+SpringBoot）开发、整合发布的模式

  1. 完善application.properties，为mvc配置静态资源路径（static目录）；如果要将视图层放在templates下，则必须采用thymeleaf，jsf等这类技术写前端。
#视图层控制
spring.mvc.static-path-pattern=/**
  1. 创建符合mvc形式的文件结构
    springmvc目录结构

创建实体类

  1. 创建实体类User，用lombok的注解代替样板代码，手写一个2参的构造函数
package com.evanpatchouli.demo.model.entity;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    int id;
    private String name;
    private String pwd;

    public User(String name, String pwd){
        this.name = name;
        this.pwd = pwd;
    }
}

Mapper层

  1. 写Mapper层，插入和查询数据
    @Mapper注解（Mybatis）声明这属于Mapper层
    @Repository是Spring JPA的一个注解，写上可以避免爆未注入Bean的错（虽然不影响运行）
    示例项目里将采用Mybatis注解编写sql语句，xml写法很容易找到，我就不拿来用了。格式：@Xxx(value = "sql语句")（"value="可省略）
    （Mybatis注解sql的好处在于快，动态sql有专门的方案，不输xml）
package com.evanpatchouli.demo.model.mapper;

import com.evanpatchouli.demo.model.entity.User;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;
import org.springframework.stereotype.Repository;

@Mapper
@Repository
public interface UserMapper {

    @Insert(value = "insert into user(name,pwd) values (#{name},#{pwd})")
    void insert(User user);

    @Select("select * from user where name=#{name} and pwd=#{pwd}")
    User select(@Param("name") String name, @Param("pwd") String pwd);
}

Service层

  1. 编写Service层，调用Mapper
    @Service声明这属于Service层，为其注册Bean
    @Autowired帮我们将参数自动注入Mapper接口
package com.evanpatchouli.demo.controller.service;

import com.evanpatchouli.demo.model.entity.User;
import com.evanpatchouli.demo.model.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public void register(User user){
        userMapper.insert(user);
    };

    public User select(String name, String pwd){
        return userMapper.select(name, pwd);
    }
}
  1. 封装一个返回体（非必要）
    封装返回体的方式有很多，自定义泛型等等，平常我更喜欢直接new一个哈希Map作为返回体
    Restful接口返回的数据结构也没有规范标准，具体不赘述，总之要保证数据，信息，成功与否传达清晰
    示例项目中，为了结构简明，我定义了几个返回值为Map的静态方法和常用Http状态码枚举类
    Result：
package com.evanpatchouli.demo.util;

import java.util.HashMap;
import java.util.Map;

public class Result {
    public static Map error() {
        Map error = new HashMap();
        error.put("code",null);
        error.put("type",null);
        error.put("info",null);
        return error;
    }

    public static Map result(){
        Map result = new HashMap();
        result.put("status",null);
        result.put("error",error());
        result.put("data",null);
        result.put("msg",null);
        return result;
    }

    public static Map ok(){
        Map result = result();
        result.replace("status",HttpStatus.OK.code);
        result.replace("error",null);
        result.replace("data",null);
        result.replace("msg","success");

        return result;
    }

    public static Map ok(String msg){
        Map result = result();
        result.replace("status",HttpStatus.OK.code);
        result.replace("error",null);
        result.replace("msg",msg);
        result.replace("data",null);

        return result;
    }

    public static Map ok(Object o, String msg){
        Map result = result();
        result.replace("status",HttpStatus.OK.code);
        result.replace("error",null);
        result.replace("msg",msg);
        result.replace("data",o);

        return result;
    }

    public static Map ResetContent(){
        Map result = result();
        result.replace("status",HttpStatus.ResetContent.code);
        Map error = error();
        error.replace("type","ResetContent");
        error.replace("info","ResetContent");
        error.replace("code",null);
        result.replace("error",error);
        result.replace("msg","error");

        return result;
    }

    public static Map ResetContent(int code, String msg){
        Map result = result();
        result.replace("status",HttpStatus.ResetContent.code);
        Map error = error();
        error.replace("type","ResetContent");
        error.replace("info","ResetContent");
        error.replace("code",code);
        result.replace("error",error);
        result.replace("msg",msg);

        return result;
    }

    public static Map Unauthorized(){
        Map result = result();
        result.replace("status",HttpStatus.Unauthorized.code);
        Map error = error();
        error.replace("type","Unauthorized");
        error.replace("info","Unauthorized");
        error.replace("code",null);
        result.replace("error",error);
        result.replace("msg","error");

        return result;
    }

    public static Map Unauthorized(int code, String msg){
        Map result = result();
        result.replace("status",HttpStatus.Unauthorized.code);
        Map error = error();
        error.replace("type","Unauthorized");
        error.replace("info","Unauthorized");
        error.replace("code",code);
        result.replace("error",error);
        result.replace("msg",msg);

        return result;
    }

    public static Map NotFound(){
        Map result = result();
        result.replace("status",HttpStatus.NotFound.code);
        Map error = error();
        error.replace("type","NotFound");
        error.replace("info","NotFound");
        error.replace("code",null);
        result.replace("error",error);
        result.replace("msg","error");

        return result;
    }

    public static Map NotFound(int code, String msg){
        Map result = result();
        result.replace("status",HttpStatus.NotFound.code);
        Map error = error();
        error.replace("type","NotFound");
        error.replace("info","NotFound");
        error.replace("code",code);
        result.replace("error",error);
        result.replace("msg",msg);

        return result;
    }

    public static Map Forbidden(){
        Map result = result();
        result.replace("status",HttpStatus.Forbidden.code);
        Map error = error();
        error.replace("type","Forbidden");
        error.replace("info","Forbidden");
        error.replace("code",null);
        result.replace("error",error);
        result.replace("msg","error");

        return result;
    }

    public static Map Forbidden(int code, String msg){
        Map result = result();
        result.replace("status",HttpStatus.Forbidden.code);
        Map error = error();
        error.replace("type","Forbidden");
        error.replace("info","Forbidden");
        error.replace("code",code);
        result.replace("error",error);
        result.replace("msg",msg);

        return result;
    }

    public static Map error(String typename, int code, String msg){
        Map result = result();
        result.replace("status",HttpStatus.valueOf(typename));
        Map error = error();
        error.replace("type",typename);
        error.replace("info",typename);
        error.replace("code",code);
        result.replace("error",error);
        result.replace("msg",msg);

        return result;
    }

    public static Map error(String typename, int code, String msg, Object o){
        Map result = error(typename, code, msg);
        result.replace("data",o);

        return result;
    }

}

HttpStatus：

package com.evanpatchouli.demo.util;

public enum HttpStatus {
    OK(200),
    ResetContent(205),
    Unauthorized(401),
    Forbidden(403),
    NotFound(404);

    public final int code;
    HttpStatus(int code) {
        this.code = code;
    }
}

也可以不按这个写，直接在Controller里new一个HashMap拿来用，比如：

//	我采取的是一种符合RFC规范的rest接口返回结构，但rest去遵守RFC，往往会比较难确定用哪个Http状态码，比如去查资料各路大佬也是对密码错误这种情况的返回码争论不休，有说200的，有说401的，有用403的，有选409的，有用422的，也有303的...细看他们阐述的理由似乎都很有道理
//	{
//		"status": 404，
//		"error": {
//			"code": 74,
//			"type": "NotFound",
//			"info": "The account you want to login do not exist!"
//		},
//		"msg": "error",
//		"data": null,	
//	}
//	不遵守RFC的rest接口，status统一200，虽然显得"不规范"，但不用头疼纠结该返回什么Http状态码，有的大厂就在这样使用，比如 META（Facebook）的
//	{
//		"status": 200,	//甚至直接不写
//		"type": "OAuthException",
//		"message": "(#803) Some of the aliases you requested do not exist: foo.bar"
//	}
Map result = new HashMap();
Map error = new HashMap();

error.put("code",1);	//错误(业务)编号，通常和Info一起存放在一个表，或者Set或者Map或者枚举类等里面，现在我这里还没有做这个Map
error.put("type","NotFound");	//Not Found，通常和它对应的数字码存在Map，枚举等等
error.put("Info","请求的资源不存在");	//先直接写了

result.put("status", 404);	//http数字码
result.put("error", error);
result.put("data", null);	//如果请求源需要返回数据，就放在这里

Controller层（api）：登陆注册接口

  1. 编写Controller层接口

    @CrossOrigin: 前后端分离时，允许请求源跨域名访问接口
    @RestController: 这代表每个接口的返回值都将被转化成JSON返回给请求源，适合前后端分离；如果是不分离开发的，采用@Controller，想返回JSON时在相应的方法上加@ResponseBody
    @RequestMapping指定笼统的url请求路径，不限制请求方式
    @GetMapping和@PostMapping代表GET和POST，PUT等等以此类推，可用以实现同一路径分化

          在这个用户接口里，用了@PathVariable和@RequestParam两种方式传参，两种放到一起来比较一下使用上的不同：虽然处理数据的方式如出一辙，但在URL上可以明显感受到不同，PathVaribale是指向不同的路径（资源），做初步的分化，RequestParam往往是对这个路径上资源进行操作所需要的参数，比如这里的model=user指向user资源，action=register指向注册这个操作，而注册user则需要name和pwd这两个参数。（极度的restful接口风格）
          @RequestParam可以设置参数是否必须传和默认值，格式：@RequestParam(required = false, defaultValue = "666") String pwd，defaultValue必须是字符串，如果你的参数类型是int, boolean等，它会自动转换，不用你手动转换类型
          实际开发中，可以不用将他们俩掺和着写，分成两个不同路径的函数就行。稍后章节还会展示另一种接受数据的方式
          注册时，先查询此号有无
          登陆时，核对一下
          如果model没对上user，或action也没对上，返回404 NotFound
package com.evanpatchouli.demo.controller;

import com.evanpatchouli.demo.controller.service.UserService;
import com.evanpatchouli.demo.model.entity.User;
import com.evanpatchouli.demo.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

@CrossOrigin
@RestController
@RequestMapping("/api")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/{model}/{action}")   // http://localhost:8080/api/register
    public Map register(@PathVariable String model, @PathVariable String action, @RequestParam String name, @RequestParam String pwd){
        if(model.equals("user")){
            User user = new User();
            switch (action){
                case "register" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        return Result.ResetContent(1,"账号已存在");
                    }
                    user =  new User(name, pwd);
                    userService.register(user);
                    user = userService.select(name, pwd);
                    return Result.ok(user, "注册成功");
                case "login" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        return Result.ok(user,"登录成功");
                    }
                    return Result.Unauthorized(1,"密码错误");
            }
        }
        return Result.NotFound();
    }

}
  1. 测试一下接口，postman，apipost都可以
    测试用例：
    （1）成功注册
    （2）注册同样的账号
    （3）登录正确的账号
    （4）输入错误的密码，登录失败
    （5）访问不存在的资源

成功注册

用户已存在
登陆成功
密码错误
资源不存在

测试结果没有问题，所以到这一步，基本的注册登录模块已经完成了。

修改密码接口

  1. 增添一个修改密码的接口

Mapper ：

@Update("update user set pwd=#{pwd} where id=#{id}")
void updatePwd(@Param("id") int id,@Param("pwd") String pwd);

Service：

public void  updatePwd(int id, String pwd) { userMapper.updatePwd(id, pwd); }

Controller：
接口传参加上@RequestParam(required = false) String pwd2

case "updatePwd" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        userService.updatePwd(user.getId(),pwd2);
                        return Result.ok("修改成功");
                    }
                    return Result.Forbidden(1,"密码错误");

测试：
（1）修改密码，原密码错误
（2）正确修改密码
原密码错误

成功修改
到这里，一个极简版的账号模块就完成了。

  1. 添加个人信息和对应的接口
    先在数据库里创建userinfo表，单独存储用户个人信息
/*
Navicat MySQL Data Transfer

Source Server         : localhost_3306
Source Server Version : 50739
Source Host           : localhost:3306
Source Database       : springdemo

Target Server Type    : MYSQL
Target Server Version : 50739
File Encoding         : 65001

Date: 2023-01-10 16:18:17
*/

SET FOREIGN_KEY_CHECKS=0;
-- ----------------------------
-- Table structure for `userinfo`
-- ----------------------------
DROP TABLE IF EXISTS `userinfo`;
CREATE TABLE `userinfo` (
  `id` int(11) NOT NULL,
  `nick` varchar(255) DEFAULT NULL,
  `phone` varchar(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

-- ----------------------------
-- Records of userinfo
-- ----------------------------

这里我将展示另一种传递接收数据的方式，新的Controller:
       新建了一个接口和增改了第一个接口，先看新增的：函数入参里面除了上面提到的pathvaribale, requestparam，多了一个@RequestBody，这和前面两个不一样，pvar和rparm都是写在url路径上的，RequestBody代表的是请求的正文，传输数据体的实体，你可以为它指定类型为一个自定义的类或者Map，这个类包含了你需要的数据字段，发送请求的正文按照你的格式写，接口接收时就能映射属性值到你自定义的类上去，好处是url上就看不到了。这个实体就叫dto。

Controller

package com.evanpatchouli.demo.controller;

import com.evanpatchouli.demo.controller.service.UserService;
import com.evanpatchouli.demo.model.entity.InfoDto;
import com.evanpatchouli.demo.model.entity.User;
import com.evanpatchouli.demo.util.Result;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.Map;

@CrossOrigin
@RestController
@RequestMapping("/api")
public class UserController {
    @Autowired
    private UserService userService;

    @PostMapping("/{model}/{action}")   // http://localhost:8080/api/
    public Map userCount(@PathVariable String model, @PathVariable String action, @RequestParam(required = false) String name, @RequestParam(required = false) String pwd, @RequestParam(required = false, defaultValue = "ni") String pwd2, @RequestParam(required = false, defaultValue = "0") int id){
        if(model.equals("user")){
            User user = new User();
            switch (action){
                case "register" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        return Result.ResetContent(1,"账号已存在");
                    }
                    user =  new User(name, pwd);
                    userService.register(user);
                    user = userService.select(name, pwd);
                    return Result.ok(user, "注册成功");
                case "login" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        return Result.ok(user,"登录成功");
                    }
                    return Result.Unauthorized(1,"密码错误");
                case "query":
                    user = userService.selectById(id);
                    if(user != null){
                        return Result.ok(user, "success");
                    }
                    break;
                case "updatePwd" :
                    user = userService.select(name, pwd);
                    if(user != null){
                        userService.updatePwd(user.getId(),pwd2);
                        return Result.ok("修改成功");
                    }
                    return Result.Forbidden(1,"密码错误");
                case "info" :
                    Map userWithInfo = userService.getUserWithInfo(id);
                    if(userWithInfo != null){
                        return Result.ok(userWithInfo, "携带Info的user");
                    }
                    break;
                default:
                    break;
            }
        }
        return Result.NotFound();
    }

    @PostMapping("/userInfo/{action}")// http://localhost:8080/api/userInfo/
    public Map userInfo(@PathVariable String action, @RequestParam(required = false, defaultValue = "0") int id, @RequestBody(required = false) InfoDto infoDto){
        switch (action) {
            case "insert":{
                if(infoDto==null){
                    return Result.ResetContent();
                }
                if(userService.selectById(infoDto.getId())==null){
                     break;
                }
                userService.insertInfo(infoDto);
                Map info = userService.selectInfo(infoDto.getId());
                if(info != null){
                     return Result.ok(info, "success");
                }
                break;
            }
            case "query":{
                Map info = userService.selectInfo(id);
                if(info != null){
                     return Result.ok(info, "success");
                }
                break;
            }
            case "alter":{
                if(infoDto==null){
                     return Result.ResetContent();
                }
                if(userService.selectById(infoDto.getId())==null){
                     break;
                }
                Map info = userService.updateInfo(infoDto);
                if(infoDto !=null){
                     return Result.ok(info, "success");
                }
                break;
             }
        }
        return Result.NotFound();
    }
}

InfoDto:

package com.evanpatchouli.demo.model.entity;

import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class InfoDto {
    private int id;
    private String nick;
    private String phone;
}

Mapper新增:
注意最后一个接口，进行了一个连接查询，返回类型是Map，因为Mybatis是根据字段建立映射关系的，所以返回类型不一定非要是一个实体类，因为我不想专门创建一个有个人信息的User2，也不想在原User里面增加个人信息属性，这样前面那个select出来的user会携带null的个人信息，这很难受，所以我使用Map接受。

	// 根据用户id获取用户
	@Select("select * from user where id=#{id}")
    User selectById(int id);
    // 插入用户信息到userinfo表
    @Insert("insert into userinfo(id,nick,phone) values (#{id},#{nick},#{phone})")
    void insertInfo(InfoDto infoDto);
	// 更新用户信息
    @Update(value = "update userinfo set nick=#{nick},phone=#{phone} where id=#{id}")
    void updateInfo(InfoDto infoDto);
	// 根据用户id获取单独的info信息
    @Select("select * from userinfo where id=#{id}")
    Map selectInfo(int id);
	// 获取用户时，携带上个人信息
    @Select("select * from user u,userinfo i where u.id=#{id} and u.id=i.id")
    Map selectUserWithInfo(int id);

Service新增：

	public User selectById(int id){ return userMapper.selectById(id); }

    public void insertInfo(InfoDto infoDto) { userMapper.insertInfo(infoDto); }

    public Map selectInfo(int id) { return userMapper.selectInfo(id); }

    public Map updateInfo(InfoDto infoDto) {
        userMapper.updateInfo(infoDto);
        return userMapper.selectInfo(infoDto.getId());
    }

    public Map getUserWithInfo(int id){
        return userMapper.selectUserWithInfo(id);
    }

测试用例：
（1）插入一条info，用户id1
（2）查询刚才的info
（3）修改刚才的info
（4）查询携带info的user，id=1
插入Info
查询info
修改Info
查询携带info的User
       测试没有问题，到这里，一个极简版的个人信息系统的后端就完成了。如果清楚了上面所讲的，恭喜成功入门springboot，已经有能力去完成一些业务简单的后端了，殊途同归。

后记

       这个示例项目里，目前，创建账号后，是没有对应的info的，如果直接拿来给前端用，前端直接调取携带info的user接口，是返回404 NotFound的。对此，后端可以在创建账号时，顺便往info里查一条默认的记录，或者前端完成注册并登录后，强制要求必须先完善个人信息。
       使用dto之前，应当检查其属性是否都不为空，我在这提供一个检查dto的静态方法

package com.evanpatchouli.demo.util;

import java.lang.reflect.Field;
import java.lang.reflect.Type;
import java.util.HashSet;
import java.util.Set;

public class DtoUtil {
    public static Boolean hasNoBlank(Object obj, Set<String> ign){
        if(obj==null){	// obj是你要检查的dto
            return false;
        }
        if(ign==null){	// ign是一个哈希Set，调用方法前把你要忽略的字段（比如类型为int的、即使为空也无所谓、接口重用有时候需要有时候不需要，另行检测等）丢进ign，检查的时候跳过它们
            ign = new HashSet<>();
        }
        Field[] fields = obj.getClass().getDeclaredFields();
        Boolean rs = true;
        for (Field field : fields) {
            field.setAccessible(true);
            Object fieldValue = null;
            String fieldName = "";
            try {
                fieldValue = field.get(obj); //得到属性值
                //Type fieldType = field.getGenericType();//得到属性类型
                fieldName = field.getName(); // 得到属性名
                //System.out.println("属性类型：" + fieldType + ",属性名：" + fieldName + ",属性值：" + fieldValue);
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
            if(ign.contains(fieldName)){
                System.out.println(fieldName+" 属性忽略检测");
                continue;
            }
            if (fieldValue == null || fieldValue.equals("")) {  //只要有一个属性值不为null 就返回false 表示对象不为null
                System.out.println("对象有空值");
                rs = false;
                break;
            }
        }
        return rs;
    }
}

项目源码

比起上面的代码稍有补充和改动
https://github.com/Evanpatchouli/SpringBoot_Demo_evanpatchouli

注释

Evanpatchouli℃
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基于SpringBoot+SpringCloud+Vue前后端分离项目实战 --开篇
天罡gg的专栏
03-07 1万+
如何高效学习Java? 毕业设计项目应该怎么做？入门实战项目应该怎么做？ 做Java开发都应该学习哪些框架技术？ 我想来跟你聊聊为什么要学习此专栏？我们经常说，看一个事儿千万不要直接陷入细节里，你应该先鸟瞰其全貌，这样能够帮助你从高维度理解问题。同样，当你迷茫想努力没有方向时，最事半功倍的方法是：找人带你! 因为过来人，更懂得如何学、如何做、如何少走弯路！ 那今天就给大家带来一门专栏课程，由 天罡gg 和 经海路大白狗 两位实力大牛合力打造的一款专栏，可以让你从0到1快速拥有企业级规范的项目实战经验！
springboot手把手教程实战-环境搭建-001
mashuangwei的专栏
10-06 674
springboot 入门课程
手把手教你入门vue+springboot开发（一）--springboot入门
dreamflyly的博客
06-01 1107
因为工作原因，需要从C/S开发转到B/S开发，搞了10几年C/C++开发，现在需要从头开始学习B/S，好在我也是一个喜欢迎接挑战的人。B/S架构选择前后端分离开发的vue+springboot框架。从本篇开始，我将以一个入门新手的角色结合实战来详细记录vue+springboot的学习过程，供vue+springboot入门者参考。
Springboot入门到精通（超详细文档）
热门推荐
cuiqwei的博客
06-24 28万+
1. Spring Boot是什么 我们知道，从 2002 年开始，Spring 一直在飞速的发展，如今已经成为了在Java EE（Java Enterprise Edition）开发中真正意义上的标准，但是随着技术的发展，Java EE使用 Spring 逐渐变得笨重起来，大量的 XML 文件存在于项目之中。繁琐的配置，整合第三方框架的配置问题，导致了开发和部署效率的降低。 2012 年 10 月，Mike Youngstrom 在 Spring jira 中创建了一个功能请求，要求在 Spring
超详细、手把手使用IDEA+SpringBoot+MyBatis搭建微信迷你小程序
weixin_42512266的博客
08-22 1万+
慕课网跟着翔仔学 快速搭建SpringBoot+Mybatis+小程序应用 分为后端SpringBoot+Mybatis后端开发和小程序前端开发 本门课程将学会： 本门课程的框架： 技术储备要求： 开始进击： 第一步：新建工程——Srping Initializr JDK1.8以上即可 编辑项目名称： 选择springboot框架： web+mybatis 选择路径： 点击完成...
手把手实战 Redis 教学
Java.慈祥
02-03 1975
「2022 年什么会火？什么该学？本文正在参与“聊聊 2022 技术趋势”征文活动 」 Redis 基础入门 简介： Redis(Remote Dictionary Server 远程字典服务) 使用 C 语言编写的，开源的 高性能 非关系型的键值对数据库 Redis 可以存储键和五种不同类型的值之间的映射 K, V 值支持五种数据类型：字符串、列表、集合、散列表、有序集合 与传统数据库不同的是 Redis 的数据是存在内存中的，所以：读写速度非常快 因此 redis 被广泛应用于缓存方向 Re
深入浅出，SpringBoot从入门到精通，实战开发全套教程
Javanewspaper的博客
11-19 1391
Spring Boot是一个全新的框架，是用来简化Spring应用的初始搭建及开发过程的，可以使用特定的方式来进行配置，可使得开发人员不在需要定义样板化的配置，所以，Spring boot能够大大简化开发模式，学习spring boot可以将你想集成的常用框架，都有对应的组件支持。 Springboot如何系统学习？ 1、理论联系实践 在很多时候，我们接触到一个新的技术的时候，最开始肯定是被这些技术涉及到的术语、词汇所困扰，不明白这些技术术语词汇的定义、概念、含义，没有这些做根基，就很难做到掌握和学习
【Arthas】阿尔萨斯手把手实战
lx1315998513的博客
12-12 1914
【Arthas】阿尔萨斯手把手实战
10分钟手把手教你快速入门SpringBoot！
2401_84103216的博客
04-27 640
分布式技术专题+面试解析+相关的手写和学习的笔记pdf还有更多Java笔记分享如下：里我们就不多说这些 endpoint 每个的作用了, 如果你感兴趣，可以给我留言，我会根据大家需求看下是否在出一期教程详细介绍一下。当然除了上面默认显示的应用健康信息，我们也可以自定义一个健康指标；我们可以选择实现 HealthIndicator 接口来实现我们的目标；
SpringBoot全套教程_Java微服务架构视频教程
11-05
4. SpringBoot入门程序 5. SpringBoot配置文件类型 6. 配置文件与配置类的属性映射方式 7. SpringBoot整合Mybatis 8. SpringBoot整合Junit 9. SpringBoot整合Redis 阶段二： SpringBoot核心原理 1. 起步依赖原理分析...
springcloud和docker实战入门
10-09
springcloud和docker实战，手把手教如何应用springcloud开发过程，工程例子在github上可以下载，配合项目源码理解更轻松
Maven手把手入门教程
12-19
** Maven手把手入门教程 ** Maven是一款强大的Java项目管理工具，它可以帮助开发者构建、管理和部署项目。在Java开发领域，Maven已经成为事实上的标准，因为它简化了项目的构建过程，通过标准化的生命周期和依赖...
springboot基于springBoot公告管理.zip
08-20
采用java技术构建的一个管理系统。整个开发过程首先对系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统功能设计、系统总体结构设计、系统数据结构设计和系统安全设计...
SpringBoot公寓租赁实战 视频教程 下载
06-17
SpringBoot公寓租赁实战 视频教程 下载 001-课程介绍.mp4 002-项目概述-移动端业务功能.mp4 003-项目概述-后台管理系统业务功能-公寓管理.mp4 004-项目概述-后台管理系统业务功能-租赁管理.mp4 005-项目概述-...
Spring Boot
hai40587的博客
08-02 1119
在处理 Spring Boot 应用中的循环依赖问题时，重要的是要保持清晰的头脑和耐心。首先，要仔细分析问题的成因和上下文环境；其次，要尝试多种解决方案并评估其优缺点；最后，要关注应用的性能和稳定性，确保所采取的解决方案不会对应用产生负面影响。通过不断地学习和实践，我们可以逐渐掌握处理循环依赖的技巧和方法，为构建高性能、稳定的 Spring Boot 应用打下坚实的基础。
基于Spring boot + Vue的灾难救援系统
NPCS_JQ的博客
08-02 441
以脚手架项目为基础完成的1.主页：echarts展示的图表2.系统管理：用户管理，角色管理，字典管理，菜单管理，日志管理3.文件管理：生成文件4.文章管理：集合富文本写文章5.公告管理：公告的管理6.轮播图管理：前台首页的轮播图7.灾难类型管理8.灾难记录9..资源调度10.预案管理11.科普信息。
Spring Boot 实现异步处理多个并行任务
心猿意码
08-02 519
在现代Web应用开发中，异步处理和多任务并行处理对于提高系统的响应性和吞吐量至关重要。Spring Boot 提供了多种机制来实现异步任务处理，本文将介绍如何利用这些机制来优化您的应用程序性能。
Spring Boot常用注解
最新发布
东皋长歌的专栏
08-03 1443
Component注解是一个通用的注解，可以用来标注任何Spring管理的bean，像@Service，@Controller，@Repository都是@Component注解的别名。用途：@Data是一个复合注解，集成了@Getter，@Setter，@ToString，@EqualsAndHashCode，@RequiredArgsConstuctor等注解。用途：用于标识控制层组件，是@Component注解的别称，用于标识Spring MVC控制器，处理Web请求并返回视图。
手把手教你学SSM+SpringBoot+MybatisPlus实战教程
"SSM+MP+BOOT.pdf 是一份关于SSM（Spring、SpringMVC、MyBatis）和SpringBoot以及MybatisPlus的学习笔记，内容涵盖了从基础到进阶的多个知识点。笔记作者通过一个入门案例介绍了MyBatis的使用，包括创建Maven工程、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值