ssm+springboot+mysql+vue3+elementplus+mybatis图书管理系统（附涵源码）

最新推荐文章于 2024-06-16 23:23:41 发布

小九(努力学习ing)

最新推荐文章于 2024-06-16 23:23:41 发布

阅读量705

点赞数 9

本文链接：https://blog.csdn.net/2301_78303474/article/details/136068295

版权

图书管理系统

gitee仓库查看vue

https://gitee.com/ma-siqi123/elementdemo.git （下载地址）

效果查看

管理员登录

管理员对用户管理进行增删改

管理员对图书列表进行批量删除操作

管理员对图书列表进行联合查询

管理员可以在借阅管理看到所有人的借阅记录

用户登录

用户在图书表进行借书操作

退出登录

1.项目概述

1.1项目名称及介绍

图书管理系统

由于图书业务繁多，人工管理比较繁琐，难免会出现一些书籍遗漏的问题。为了保障同学借书方便，管理员管理方便，因此开发了可以实现图书的添加查询和储存等功能的管理系统。

1.2系统功能分析

（1）登录：

用户和管理员在登录页面用用户名和密码进行登录。

（2）用户管理：

管理员可以对所有的用户信息进行增删改查。

（3）图书管理：

一般用户--->一般用户只可以进行图书的联合查询，借书功能。

管理员------->管理员可以对图书列表进行批量删除，单选删除，联合查询，添加图书，编辑图书。

（4）借阅管理

一般用户--->一般用户在借阅管理列表只能查询到自己所借阅的图书信息，可以实现还书功能。

管理员------>管理员在借阅管理列表可以查询到所有登录人员的借阅记录，有催还功能。

（5）退出登录

点击退出按钮可以退出登录，储存会话信息将会被清空。

2.数据库设计

create database if not exists myTable;
use myTable;
drop table if exists userTable;
# 用户表
create table if not exists userTable
(
    id       int primary key auto_increment comment 'id',
    username varchar(10) not null unique comment '用户名',
    password varchar(10) not null comment '密码',
    type     varchar(10) default 'guest' comment '权限'
    ) engine = InnoDB;

insert into userTable
values (0, 'admin', 'admin', 'admin'),
       (0, 'guest1', '111111', 'guest'),
       (0, 'guest2', '222222', 'guest');

select *
from userTable;
# 图书表
create table if not exists bookTable
(
    bookid    int primary key auto_increment,
    bookname  varchar(100) unique,
    price     int not null,
    isbn      varchar(100) unique,
    thumbnail varchar(100) unique,
    total     int not null,
    plus      int not null
    ) engine = InnoDB;
insert into bookTable
values (1, 'java', 21, '1001', null, 42, 20),
       (2, 'pathon', 43, '1002', null, 45, 75),
       (3, 'mysql', 12, '1003', null, 71, 55),
       (4, 'vue', 50, '1004', null, 4, 240),
       (5, 'ssm', 43, '1005', null, 54, 45);
drop table if exists bookTable;
select *
from bookTable;

# 借书表
create table if not exists borrow_info
(
    borrowId       int auto_increment primary key comment '借书id',
    borrowTime     Date comment '借书时间',
    bookid         int          not null comment '对指定借书的bookid的外键',
    id             int          not null comment '用户id外键',
    returnTime     Date comment '还书时间'
);

insert into borrow_info
values (0, now(),  1, 2, now()),
       (0, now(),  1, 3, now()),
       (0, now(),  5, 2, null),
       (0, now(),  4, 3, null),
       (0, now(),  3, 1, now()),
       (0, now(),  4, 3, null);
# 一对多
select bi.borrowId, u.username, u.id, book.bookid, book.bookname,  bi.returnTime
from bookTable book
         inner join
     borrow_info bi on book
                           .bookid = bi
                           .bookid
         inner join userTable u on u.id = bi.id;

# 增添一条记录
# update borrow_info
    # set bookid=
              # #{bookid},borrowBookName=#{borrowBookName},borrowTime=#{borrowTime},returnTime=#{returnTime};

# 减少一个库存量
# update bookTable set plus=plus-1 where bookid=*{bookid};

# select *from borrow_info where bookid=#{bookid} and id=#{id} and returnTime is null;

# 删除一条记录
# delete
# from borrow_info
# where bookid = bookid;


# 还书
# update borrow_info
    # set returnTime=current_date()
        # where id = #{id}

3.详情设计及编码

Entity层

权限类AuthorityEntity

package com.example.springbootmybatis.entity;

import lombok.Data;

@Data
public class AuthorityEntity {
    private String aid;
    private String authorityName;
}

图书类BookEntity

package com.example.springbootmybatis.entity;

import lombok.Data;

@Data
public class BookEntity {
    private Integer bookid;
    private String bookname;
    private Integer price;
    private String isbn;
    private String thumbnail;
    private Integer total;
    private Integer plus;
}

借书类BorrowBookEntity

package com.example.springbootmybatis.entity;

import lombok.Data;

import java.util.Date;

@Data
public class BorrowBookEntity {
    //借书表
    private Date borrowTime;
    private Integer borrowId;
    private Integer bookid;
    private Integer id;
    private Date returnTime;
    private BookEntity book; //一对一
}

还书信息类GetBorrowEntityVo

package com.example.springbootmybatis.entity;

import lombok.Data;

@Data
public class GetBorrowEntityVo {
    private Integer bookid;
    private Integer borrowId;
}

编辑用户信息类GetUserEntityVo

package com.example.springbootmybatis.entity;

import lombok.Data;

@Data
public class GetUserEntityVo {
    private Integer id;
        private String username;
    private String password;
    private String type;
}

结果工具类RestMap

package com.example.springbootmybatis.entity;

import lombok.Data;

@Data
public class RestMap<T> {
    private  Integer code;
    private String msg;
    private T result;
}

用户类UserEntity

package com.example.springbootmybatis.entity;

import lombok.Data;

import java.util.List;

@Data
public class UserEntity {
    private Integer id;
    private String username;
    private String password;
    private String type;
    private String authorityId;
    private AuthorityEntity authorityEntity;
    private List<BorrowBookEntity> borrowList;//一对多复杂查询

}

控制层

BookController

package com.example.springbootmybatis.Controller;

import com.example.springbootmybatis.entity.BookEntity;
import com.example.springbootmybatis.entity.BorrowBookEntity;
import com.example.springbootmybatis.entity.GetBorrowEntityVo;
import com.example.springbootmybatis.entity.RestMap;
import com.example.springbootmybatis.mapper.BookMapper;
import com.example.springbootmybatis.util.ToolUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@CrossOrigin
@RestController
@RequestMapping("/book")
public class BookController {
    @Autowired
    BookMapper bookMapper;

    //查询图书列表
    @RequestMapping("/getAllBooks")
    public RestMap getAllBooks() {
        List<BookEntity> allBooks = bookMapper.getAllBooks();
        return ToolUtil.optionRestMap(allBooks, "查询");
    }


    //联合查询
    @RequestMapping("/getBooksByWhere")
    public RestMap getBooksByWhere(@RequestBody BookEntity bookEntity) {
        List<BookEntity> booksByWhere = bookMapper.getBooksByWhere(bookEntity);
        return ToolUtil.optionRestMap(booksByWhere, "查询");
    }

    //批量删除
    @RequestMapping("/deleteBookByIDs")
    public RestMap<Integer> deleteBookByIDs(@RequestBody List<Integer> ids) {
        RestMap<Integer> restMap = new RestMap<>();
        int i = bookMapper.deleteBookByIDs(ids);
        if (i > 0) {
            restMap.setResult(i);
            restMap.setMsg("删除成功");
            // restMap.setCode(200); ----------》返回值是200的话就显示删除成功
            restMap.setCode(200);
        } else {
            restMap.setCode(-1);
            restMap.setResult(i);
            restMap.setMsg("删除失败");
        }
        return restMap;
    }

    @RequestMapping("/getBorrowBookEntity/{id}")
    public RestMap getBorrowBookEntity(@PathVariable Integer id) {
        List<BorrowBookEntity> borrowBookEntity = bookMapper.getBorrowBookEntity(id);
        return ToolUtil.optionRestMap(borrowBookEntity, "查询");
    }

    @RequestMapping("/insertLendBook")

    public RestMap insertLendBook(@RequestBody BorrowBookEntity borrowBook) {
        RestMap<Integer> restMap = new RestMap<>();
        //2.判断这本书被这个人借没借书 ，没有还没还  用户id  图书bookid  retunTime 不为空表示借书了没还
        List<BorrowBookEntity> borrowBook1 = getCheckBorrowBookInfo(borrowBook);
        if (borrowBook1.size() > 0) {
            restMap.setCode(-1);
            restMap.setMsg("你已经借过这本书了还没还");
        } else {
            //1.点击借书按钮借阅管理增加一条记录 insert ,返回值为1
            int i = bookMapper.insertLendBook(borrowBook);
            //3.图书表库存量减少1,返回值为200
            int j = bookMapper.borrowPlusId(borrowBook.getBookid());
            //如果添加了并且有库存则借书成功
            if (i == 1 && j > 0) {
                restMap.setCode(200);
                restMap.setMsg("借书成功");
                restMap.setResult(i + j);
            } else {
                restMap.setCode(-1);
                restMap.setMsg("借书失败");
            }
        }
        return restMap;


    }

    public List<BorrowBookEntity> getCheckBorrowBookInfo(BorrowBookEntity borrowBook) {
        List<BorrowBookEntity> checkBorrowBookInfo = bookMapper.getCheckBorrowBookInfo(borrowBook);
        return checkBorrowBookInfo;
    }

    @RequestMapping("/returnBorrowBook")
    public RestMap returnBorrowBook(@RequestBody GetBorrowEntityVo Vo){
        RestMap<Integer> restMap=new RestMap<>();
        int i = bookMapper.returnBorrowBook(Vo);
        if (i>0){
            int j = bookMapper.returnPlusId(Vo);
            restMap.setCode(200);
            restMap.setResult(j);
            restMap.setMsg("借书成功");
        }
        return restMap;
    }

//      @RequestMapping("/returnBorrowBook/{borrowId}/{bookid}")
//       public RestMap returnBorrowBook(@PathVariable Integer borrowId ,@PathVariable Integer bookid ) {
//        RestMap<Integer> restMap=new RestMap<>();
//        //还书 1.更新还书时间
//        //2.更新库存数量
//          int i = bookMapper.returnBorrowBook(borrowId);
//          if (i>0){
//              int j = bookMapper.returnPlusId(bookid);
//              restMap.setCode(200);
//              restMap.setResult(j);
//              restMap.setMsg("借书成功");
//          }
//          return restMap;
//
//      }
}

UserController

package com.example.springbootmybatis.Controller;

import com.example.springbootmybatis.entity.GetUserEntityVo;
import com.example.springbootmybatis.entity.RestMap;
import com.example.springbootmybatis.entity.UserEntity;
import com.example.springbootmybatis.mapper.UserMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

@CrossOrigin
@RestController
@RequestMapping("/user")
public class UserController {
    @Autowired
    UserMapper userMapper;

    @RequestMapping("/getAllUsers")
    public RestMap<List<UserEntity>> getAllUsers() {
        List<UserEntity> allUsers = userMapper.getAllUsers();
        RestMap<List<UserEntity>> restMap = new RestMap<>();
        if (allUsers != null) {
            restMap.setMsg("查询成功");
            restMap.setResult(allUsers);
            restMap.setCode(200);
        } else {
            restMap.setCode(-1);
            restMap.setMsg("没有数据");
        }
        return restMap;

    }

    //登录
    @RequestMapping("/login")
    public RestMap<UserEntity> login(@RequestBody UserEntity userEntity) {
        RestMap<UserEntity> resultMap = new RestMap<>();
        UserEntity loginUser = userMapper.login(userEntity);
        if (loginUser != null) {
            resultMap.setCode(200);
            resultMap.setMsg("登陆成功");
            resultMap.setResult(loginUser);
        } else {
            resultMap.setCode(-1);
            resultMap.setMsg("登录失败，用户密码错误");
        }
        return resultMap;
    }

    @RequestMapping("/getUserAndAuthority")
    public List<UserEntity> getUserAndAuthority() {
        return userMapper.getUserAndAuthority();
    }


    //添加用户
    @RequestMapping("/insertUser")
    public RestMap insertUser(@RequestBody UserEntity userEntity){
        RestMap<Integer> restMap = new RestMap<>();
        List<UserEntity> checkUserInfo = getCheckUserInfo(userEntity);
        //1.判断用户是否存在
        if (checkUserInfo.size()==0){
            int i = userMapper.insertUser(userEntity);
            if (i==1){
                //2.添加一条用户记录
                restMap.setCode(200);
                restMap.setMsg("添加成功");
                restMap.setResult(i );
            }else {
                restMap.setCode(-1);
                restMap.setMsg("添加失败");
            }
        }
        return restMap;
    }

    public List<UserEntity> getCheckUserInfo(UserEntity userEntity) {
        List<UserEntity> checkUserInfo = userMapper.getCheckUserInfo(userEntity);
        return checkUserInfo;
    }

    //删除用户通过id
    @RequestMapping("/deleteUser/{id}")
    public RestMap deleteUser(@PathVariable Integer id){
        RestMap<Integer> restMap = new RestMap<>();
        int i = userMapper.deleteUser(id);
        if (i>0){
            restMap.setResult(i);
            restMap.setCode(200);
            restMap.setMsg("删除成功");
        }else {
            restMap.setCode(-1);
            restMap.setMsg("删除失败");
        }
        return restMap;
    }

    //编辑用户
    @RequestMapping("/updateUser")
    public RestMap updateUser(@RequestBody GetUserEntityVo vo){
        RestMap<Integer> restMap=new RestMap<>();
        int i = userMapper.updateUser(vo);
        if (i>0){
            restMap.setCode(200);
            restMap.setResult(i);
            restMap.setMsg("借书成功");
        }else {
            restMap.setCode(-1);
            restMap.setMsg("借书失败");
        }
        return restMap;
    }



}

Mapper接口层

BookMapper类

package com.example.springbootmybatis.mapper;

import com.example.springbootmybatis.entity.BookEntity;


import com.example.springbootmybatis.entity.BorrowBookEntity;
import com.example.springbootmybatis.entity.GetBorrowEntityVo;
import org.apache.ibatis.annotations.Mapper;

import java.util.List;

@Mapper
public interface BookMapper {
    public List<BookEntity> getAllBooks(); //图书列表 简单逻辑用select查询 复杂的新建bookMapper.xml配置文件方式@Select("select *from bookTable")

    public List<BookEntity> getBooksByWhere(BookEntity bookEntity);//联合查询

    public int deleteBookByIDs(List<Integer> ids);  //批量删除@Delete("delete from bookTable where bookid in(1,2,3)")

    public int insertLendBook(BorrowBookEntity borrowBook); //图书借书向借阅管理添加一条数据

    public int borrowPlusId(Integer bookid);//修改借书信息,减少一个库存量  修改还书信心，增加一个库存量

    public List<BorrowBookEntity> getCheckBorrowBookInfo(BorrowBookEntity entity);//判断这个人借没借过这本书还没还

    public List<BorrowBookEntity> getBorrowBookEntity(Integer id);   //展示借阅管理element plus table嵌套

    public  int returnBorrowBook(GetBorrowEntityVo Vo);
//    public int returnBorrowBook (Integer borrowId );//还书-借阅管理更新还书时间 更新plus

    public int returnPlusId(GetBorrowEntityVo Vo);
//    public int returnPlusId(Integer bookid);
   //修改还书信息，增加一个库存量
}

UserMapper类

package com.example.springbootmybatis.mapper;

import com.example.springbootmybatis.entity.GetUserEntityVo;
import com.example.springbootmybatis.entity.UserEntity;
import org.apache.ibatis.annotations.Mapper;


import java.util.List;
@Mapper
public interface UserMapper {

    public UserEntity login(UserEntity userEntity);//登录 参数UserEntity 返回方法UserEntity


    public  List<UserEntity> getAllUsers(); //查询整个用户表单信息

    List<UserEntity> getUserAndAuthority(); //一对一 用户---权限

    public int insertUser(UserEntity userEntity);//添加用户

    public List<UserEntity> getCheckUserInfo(UserEntity userEntity);//判断这个用户是否存在

    public int deleteUser(Integer id);//删除用户

    public  int updateUser(GetUserEntityVo Vo);//编辑用户

}

util层

ToolUtil

package com.example.springbootmybatis.util;

import com.example.springbootmybatis.entity.RestMap;

public class ToolUtil {
    /**
     * 处理结果集
     */
    public static RestMap<?extends Object> optionRestMap(Object obj ,String msg){
        RestMap<Object> restMap=new RestMap<>();
        if (obj != null) {
            restMap.setCode(200);
            restMap.setResult(obj);
            restMap.setMsg(msg+"成功");
        } else {
            restMap.setCode(-1);
            restMap.setMsg(msg+"失败");
        }
        return restMap;
    }


}

resources文件下mapper配置

BookMapper.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.example.springbootmybatis.mapper.BookMapper">
    <select id="getAllBooks" parameterType="BookEntity" resultType="BookEntity">
        <include refid="selectAllBook"></include>
    </select>
    <sql id="selectAllBook">
        select *
        from bookTable
    </sql>


    <delete id="deleteBookByIDs" parameterType="list">
        delete from booktable where bookid in
        <foreach collection="ids" open="(" close=")" separator="," item="item">
            #{item}
        </foreach>
    </delete>

    <select id="getBooksByWhere" parameterType="BookEntity" resultType="BookEntity">
        <include refid="selectAllBook"></include>
        <where>
            <if test="bookname!=null and bookname!=''">
                and bookname like '%${bookname}'
            </if>
            <if test="price!=null and price!=0">
                and price>#{price}
            </if>
        </where>
    </select>


    <select id="getBorrowBookEntity" parameterType="Integer" resultMap="UserBookMapper">
        select bi.borrowId,
        u.username,
        u.id,
        book.bookid,
        book.bookname,
        bi.borrowTime,
        bi.returnTime,
        bi.id
        from bookTable book
        inner join borrow_info bi on book.bookid = bi.bookid
        inner join userTable u on u.id = bi.id
        <where>
            <if test="id !=null and id !=0">
                u.id=#{id};
            </if>
        </where>
    </select>

    <resultMap id="UserBookMapper" type="UserEntity">
        <id column="id" property="id"></id>
        <result column="username" property="username"></result>
        <collection property="borrowList" ofType="BorrowBookEntity">
            <id column="borrowId" property="borrowId"></id>
            <result column="borrowTime" property="borrowTime"></result>
            <result column="returnTime" property="returnTime"></result>
            <result column="id" property="id"></result>
            <association property="book" javaType="BookEntity">
                <id column="bookid" property="bookid"></id>
                <result column="bookname" property="bookname"></result>
            </association>
        </collection>
    </resultMap>
    <!--    添加一条借书记录-->
    <insert id="insertLendBook" parameterType="BorrowBookEntity">
        insert into borrow_info (bookid, borrowTime, returnTime, id, borrowId)
        values (#{bookid},
                #{borrowTime},
                #{returnTime},
                #{id},
                0)
    </insert>
    <!--    修改借书信息,减少一个库存量-->
    <update id="borrowPlusId" parameterType="Integer">
        update bookTable
        set plus=plus - 1
        where bookid = #{bookid}
    </update>

    <!--   判断 这个人借没借过这本书还没还-->
    <select id="getCheckBorrowBookInfo" parameterType="BorrowBookEntity" resultType="BorrowBookEntity">
        select *
        from borrow_info
        where bookid = #{bookid}
          and id = #{id}
          and returnTime is null
    </select>

    <!--    还书 1.更新还书时间-->
    <update id="returnBorrowBook" parameterType="GetBorrowEntityVo">
        update borrow_info
        set returnTime=current_date()
        where borrowId = #{borrowId}

    </update>
    <!--    还书 2.更新图书表的库存量-->
    <update id="returnPlusId" parameterType="GetBorrowEntityVo">
        update bookTable
        set plus=plus + 1
        where bookid = #{bookid}
    </update>


</mapper>

UserMapper

<?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.example.springbootmybatis.mapper.UserMapper">
    <select id="getAllUsers" resultType="UserEntity">
        select *
        from userTable
    </select>

    <select id="login"
            parameterType="UserEntity"
            resultType="UserEntity">

        select *
        from userTable
        where username = #{username}
          and password = #{password}
    </select>


    <select id="getUserAndAuthority" resultMap="UserAndAuthority">
        select u.username, u.id, u.password, a.authorityId as aid, a.authorityName
        from userTable u
                 left join authoritytable a on u.authorityId = a.authorityId
    </select>
    <resultMap id="UserAndAuthority" type="UserEntity">
        <id column="id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="password" property="password"></result>
        <result column="authorityId" property="aid"></result>
        <!--    一对一关键字是association-->
        <association property="authorityEntity" javaType="AuthorityEntity">
            <id column="authorityId" property="authorityId"></id>
            <result column="authorityName" property="authorityName"></result>
        </association>
    </resultMap>

<!--    添加用户-->
    <insert id="insertUser" parameterType="UserEntity" >
        insert into userTable
        values (0,
                #{username},
                #{password},
                #{type}
                )
    </insert>

    <!--   判断 用户是否存在-->
    <select id="getCheckUserInfo" parameterType="UserEntity" resultType="UserEntity">
        select *
        from usertable
        where id = #{id}
          and username = #{username}
          and password = #{password}
    </select>

<!--    删除用户通过id删除-->
    <delete id="deleteUser" parameterType="Integer" >
        delete from usertable where id=#{id}
    </delete>

<!--    用户编辑-->
<update id="updateUser" parameterType="GetUserEntityVo">
    update usertable
    set id=#{id},username=#{username},password=#{password},type=#{type}
    where id = #{id}
</update>
</mapper>

application.xml配置

spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    username: root
    password: root
    url: jdbc:mysql://localhost:3306/mytable
mybatis:
  mapper-locations: classpath:/mapper/*.xml
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  type-aliases-package: com.example.springbootmybatis.entity

server:
  port: 9000

pom.xml配置

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>3.1.6</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>springbootMybatis</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springbootMybatis</name>
    <description>springbootMybatis</description>
    <properties>
        <java.version>17</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>3.0.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </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>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter-test</artifactId>
            <version>3.0.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <image>
                        <builder>paketobuildpacks/builder-jammy-base:latest</builder>
                    </image>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

如需原素材请后台私信我

小九(努力学习ing)

关注

9
点赞
踩
20

收藏

觉得还不错? 一键收藏
1
评论
ssm+springboot+mysql+vue3+elementplus+mybatis图书管理系统（附涵源码）

项目名称及介绍图书管理系统由于图书业务繁多，人工管理比较繁琐，难免会出现一些书籍遗漏的问题。为了保障同学借书方便，管理员管理方便，因此开发了可以实现图书的添加查询和储存等功能的管理系统。
复制链接

扫一扫