SpringBoot多模块项目创建和初始化问题

lease
├── common（公共模块——工具类、公用配置等）
│   ├── pom.xml
│   └── src
├── model（数据模型——与数据库相对应地实体类）
│   ├── pom.xml
│   └── src
├── web（web模块）
│   ├── pom.xml
│   ├── web-admin（后台管理系统web模块——包含mapper、service、controller）
│   │   ├── pom.xml
│   │   └── src
│   └── web-app（移动端web模块——包含mapper、service、controller）
│       ├── pom.xml
│       └── src
└── pom.xml

# 注意：是在web父模块的pom.xml里添加的,添加后刷新一下maven
    <dependencies>
        <dependency>
            <groupid>com</groupid># 创建模块的组id
            <artifactid>common</artifactid>
            <version>0.0.1-snapshot</version>
        </dependency>
        <dependency>
            <groupid>com</groupid>
            <artifactid>model</artifactid>
            <version>0.0.1-snapshot</version>
        </dependency>
    </dependencies>

    <!-- 继承spring boot父项目 -->
    <parent>
        <groupid>org.springframework.boot</groupid>
        <artifactid>spring-boot-starter-parent</artifactid>
        <version>3.0.5</version>
        <relativepath/>
    </parent>
    <!-- 注意：直接替换pom文件中原有的properties -->
    <properties>
        <maven.compiler.source>21</maven.compiler.source>
        <maven.compiler.target>21</maven.compiler.target>
        <project.build.sourceencoding>utf-8</project.build.sourceencoding>
        <!-- 统一声明依赖的版本，直接通过${}引用 -->
        <lombok.version>1.18.34</lombok.version>
        <mybatis-plus.version>3.5.3.1</mybatis-plus.version>
        <swagger.version>2.9.2</swagger.version>
        <jwt.version>0.11.2</jwt.version>
        <easycaptcha.version>1.6.2</easycaptcha.version>
        <minio.version>8.2.0</minio.version>
        <knife4j.version>4.1.0</knife4j.version>
        <aliyun.sms.version>2.0.23</aliyun.sms.version>
    </properties>
    <!--配置dependencymanagement统一管理依赖版本-->
    <dependencymanagement>
        <dependencies>
            <!--mybatis-plus-->
            <!--官方文档：https://baomidou.com/pages/bab2db/ -->
            <dependency>
                <groupid>com.baomidou</groupid>
                <artifactid>mybatis-plus-boot-starter</artifactid>
                <version>${mybatis-plus.version}</version>
            </dependency>
            <!--knife4j文档-->
            <!--官方文档：https://doc.xiaominfo.com/docs/quick-start -->
            <dependency>
                <groupid>com.github.xiaoymin</groupid>
                <artifactid>knife4j-openapi3-jakarta-spring-boot-starter</artifactid>
                <version>${knife4j.version}</version>
            </dependency>
            <!--jwt登录认证相关-->
            <!--官方文档：https://github.com/jwtk/jjwt#install-jdk-maven -->
            <dependency>
                <groupid>io.jsonwebtoken</groupid>
                <artifactid>jjwt-api</artifactid>
                <version>${jwt.version}</version>
            </dependency>
            <dependency>
                <groupid>io.jsonwebtoken</groupid>
                <artifactid>jjwt-impl</artifactid>
                <scope>runtime</scope>
                <version>${jwt.version}</version>
            </dependency>
            <dependency>
                <groupid>io.jsonwebtoken</groupid>
                <artifactid>jjwt-jackson</artifactid>
                <scope>runtime</scope>
                <version>${jwt.version}</version>
            </dependency>
            <!--图形验证码-->
            <!--官方文档：https://gitee.com/ele-admin/easycaptcha -->
            <dependency>
                <groupid>com.github.whvcse</groupid>
                <artifactid>easy-captcha</artifactid>
                <version>${easycaptcha.version}</version>
            </dependency>
            <!--对象存储，用于存储图像等非结构化数据-->
            <!--官方文档：https://min.io/docs/minio/linux/developers/minio-drivers.html?ref=docs#java-sdk -->
            <dependency>
                <groupid>io.minio</groupid>
                <artifactid>minio</artifactid>
                <version>${minio.version}</version>
            </dependency>
            <!--阿里云短信客户端，用于发送短信验证码-->
            <!--官方文档：https://help.aliyun.com/document_detail/215759.html?spm=a2c4g.215759.0.0.49f32807f4yc0y -->
            <dependency>
                <groupid>com.aliyun</groupid>
                <artifactid>dysmsapi20170525</artifactid>
                <version>${aliyun.sms.version}</version>
            </dependency>
			<dependency>
                <groupid>org.projectlombok</groupid>
                <artifactid>lombok</artifactid>
                <version>${lombok.version}</version>
                <scope>provided</scope>
            </dependency>
        </dependencies>
    </dependencymanagement>

# 在dependeencies里添加需要的依赖
<dependencies>
	<!--包含spring web相关依赖-->
	<dependency>
    	<groupid>org.springframework.boot</groupid>
	    <artifactid>spring-boot-starter-web</artifactid>
	</dependency>
	<!--包含spring test相关依赖-->
	<dependency>
    	<groupid>org.springframework.boot</groupid>
	    <artifactid>spring-boot-starter-test</artifactid>
    	<scope>test</scope>
	</dependency>
</dependencies>
<!-- spring boot maven插件，用于打包可执行的jar文件 -->
<build>
    <plugins>
        <plugin>
            <groupid>org.springframework.boot</groupid>
            <artifactid>spring-boot-maven-plugin</artifactid>
        </plugin>
    </plugins>
</build>

# 配置启动端口号
server:
  port: 8080

@springbootapplication
public class adminwebapplication {
    public static void main(string[] args) {
        springapplication.run(adminwebapplication.class, args);
    }
}

    <dependencies>
        <!--mybatis-plus-->
        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatis-plus-boot-starter</artifactid>
        </dependency>
        <!--mysql驱动-->
        <dependency>
            <groupid>com.mysql</groupid>
            <artifactid>mysql-connector-j</artifactid>
        </dependency>
    </dependencies>

    <dependencies>
        <!--mybatis-plus-->
        <dependency>
            <groupid>com.baomidou</groupid>
            <artifactid>mybatis-plus-boot-starter</artifactid>
        </dependency>
    </dependencies>

spring:
  datasource:
    type: com.zaxxer.hikari.hikaridatasource # 指定数据库连接池类型
    url: jdbc:mysql://192.168.23.101:3306/lease?useunicode=true&characte
    # url: jdbc:mysql://数据库的ip地址:端口号/要连接的数据库名?useunicode=true&characterencoding=utf-8&usessl=false&allowpublickeyretrieval=true&servertimezone=gmt%2b8
    username: 数据库账号名
    password: 数据库账号密码
    # 配置连接池参数
    hikari:
      connection-test-query: select 1 # 自动检测连接
      connection-timeout: 60000 #数据库连接超时时间,默认30秒
      idle-timeout: 500000 #空闲连接存活最大时间，默认600000（10分钟）
      max-lifetime: 540000 #此属性控制池中连接的最长生命周期，值0表示无限生命周期，默认1800000即30分钟
      maximum-pool-size: 12 #连接池最大连接数，默认是10
      minimum-idle: 10 #最小空闲连接数量
      pool-name: sphhikaripool # 连接池名称
#用于打印框架生成的sql语句，便于调试
mybatis-plus:
  configuration:
    log-impl: org.apache.ibatis.logging.stdout.stdoutimpl

  # 方法一：date类型数据json序列化框架全局配置
  jackson:
    date-format: yyyy-mm-dd hh:mm:ss #定义全局日期格式
    time-zone: gmt+8 # 定义全局日期时区

方法二：实体类里独立配置date类型数据格式和时区
@jsonformat(pattern = "yyyy-mm-dd hh:mm:ss")
@jsonformat(timezone = "gmt+8")
private date appointmenttime;

@configuration
@mapperscan("com.lease.web.*.mapper")# 项目里的mapper接口的目录
public class mybatisplusconfiguration {
    @bean
    // 分页配置
    public mybatisplusinterceptor mybatisplusinterceptor() {
        mybatisplusinterceptor interceptor = new mybatisplusinterceptor();
        interceptor.addinnerinterceptor(new paginationinnerinterceptor(dbtype.mysql));
        return interceptor;
    }
}

<dependency>
    <groupid>com.github.xiaoymin</groupid>
    <artifactid>knife4j-openapi3-jakarta-spring-boot-starter</artifactid>
</dependency>

@configuration
public class knife4jconfiguration {

    // 配置接口文档标题
    @bean
    public openapi openapi() {
        return new openapi()
                .info(new info()
                        .title("hello-knife4j项目api")
                        .version("1.0")
                        .description("hello-knife4j项目的接口文档"));
    }

    // 配置接口的分类，以/user/开头的接口都规划到‘用户信息管理'
    @bean
    public groupedopenapi userapi() {
        return groupedopenapi.builder().group("用户信息管理").
                pathstomatch(
                        "/user/room",// 精确匹配，只匹配/user/room的路径
                        "/user/room/*",// 单层匹配，只匹配/user/room/list这种单层的路径，多层的就不匹配了，必须有单层路径
                        "/user/room/**",// 通配匹配,会匹配所有以/user/room开头的路径，可以是单/多层或者是/user/room这个路径,使用通配匹配就不需要精确匹配和单层匹配了
                        "/user/*/room/**",// 混合使用
                        "/user/info/**",// 接口地址可以写多个
                        "/admin/**"// 可以写，但不建议开头不同的写一起，会造成文档分组语义混乱
                ).
                build();
    }

    // 配置接口的分类，以/product/开头的接口都规划到‘产品信息管理'
    @bean
    public groupedopenapi systemapi() {
        return groupedopenapi.builder().group("产品信息管理").
                pathstomatch("/product/**").
                build();
    }
}

# knife4j接口参数打平
springdoc:
  default-flat-param-object: true

/**
 * 全局统一返回结果类
 */
@data
public class result<t> {

    //返回码
    private integer code;

    //返回消息
    private string message;

    //返回数据
    private t data;

    public result() {
    }

    private static <t> result<t> build(t data) {
        result<t> result = new result<>();
        if (data != null)
            result.setdata(data);
        return result;
    }

    // 自定义错误码和错误消息
    public static <t> result<t> build(t body, resultcodeenum resultcodeenum) {
        result<t> result = build(body);
        result.setcode(resultcodeenum.getcode());
        result.setmessage(resultcodeenum.getmessage());
        return result;
    }

    // 操作成功，需要返回数据给前端
    public static <t> result<t> ok(t data) {
        return build(data, resultcodeenum.success);
    }

    // 操作成功，但不需要返回数据（如新增、修改、删除）
    public static <t> result<t> ok() {
        return result.ok(null);
    }

    // 操作失败，不需要返回额外数据
    public static <t> result<t> fail() {
        return build(null, resultcodeenum.fail);
    }

    // 操作失败，返回自定义异常
    public static <t> result<t> fail(integer code, string message) {
        result<t> result = build(null);
        result.setcode(code);
        result.setmessage(message);
        return result;
    }
}

/**
 * 统一返回结果状态信息类
 */
@getter
public enum resultcodeenum {
    // 定义枚举类常量
    success(200, "成功"),
    fail(201, "失败"),
    param_error(202, "参数不正确"),
    service_error(203, "服务异常"),
    data_error(204, "数据异常"),
    illegal_request(205, "非法请求"),
    repeat_submit(206, "重复提交"),
    delete_error(207, "请先删除子集"),

    admin_account_exist_error(301, "账号已存在"),
    admin_captcha_code_error(302, "验证码错误"),
    admin_captcha_code_expired(303, "验证码已过期"),
    admin_captcha_code_not_found(304, "未输入验证码"),


    admin_login_auth(305, "未登陆"),
    admin_account_not_exist_error(306, "账号不存在"),
    admin_account_error(307, "用户名或密码错误"),
    admin_account_disabled_error(308, "该用户已被禁用"),
    admin_access_forbidden(309, "无访问权限"),

    app_login_auth(501, "未登陆"),
    app_login_phone_empty(502, "手机号码为空"),
    app_login_code_empty(503, "验证码为空"),
    app_send_sms_too_often(504, "验证法发送过于频繁"),
    app_login_code_expired(505, "验证码已过期"),
    app_login_code_error(506, "验证码错误"),
    app_account_disabled_error(507, "该用户已被禁用"),


    token_expired(601, "token过期"),
    token_invalid(602, "token非法");

    // 对应这result里定义的变量
    private final integer code;

    private final string message;

    // 构造方法，给枚举类赋值
    resultcodeenum(integer code, string message) {
        this.code = code;
        this.message = message;
    }
}

<!--spring-web-->
<dependency>
    <groupid>org.springframework.boot</groupid>
    <artifactid>spring-boot-starter-web</artifactid>
</dependency>

@data
public class leaseexception extends runtimeexception {
    //异常状态码
    private integer code;

    /**
     * 通过状态码和错误消息创建异常对象
     *
     * @param message
     * @param code
     */
    public leaseexception(string message, integer code) {
        super(message);
        this.code = code;
    }

    /**
     * 根据响应结果枚举对象创建异常对象
     *
     * @param resultcodeenum
     */
    public leaseexception(resultcodeenum resultcodeenum) {
        super(resultcodeenum.getmessage());
        this.code = resultcodeenum.getcode();
    }

    @override
    public string tostring() {
        return "leaseexception{" +
                "code=" + code +
                ", message=" + this.getmessage() +
                '}';
    }
}

@controlleradvice
public class globalexceptionhandler {
    @exceptionhandler(exception.class)
    @responsebody
    public result error(exception e){
        e.printstacktrace();
        return result.fail();
    }

    @exceptionhandler(leaseexception.class)
    @responsebody
    public result error(leaseexception e){
        e.printstacktrace();
        return result.fail(e.getcode(), e.getmessage());
    }
}

@override
public void removeapartmentbyid(long id) {
	// 调用异常类的方法，需要提前在resultcodeenum枚举类里定义好要返回的code和message
	throw new leaseexception(resultcodeenum.token_expired);
	// 或者
	// throw new leaseexception(310,"请先删除房间信息");
}

@data
public class baseentity implements serializable {
    @schema(description = "主键")// 字段描述
    @tableid(value = "id", type = idtype.auto)// 对应表主键id
    private long id;

    @schema(description = "创建时间")
    @tablefield(value = "create_time",fill = fieldfill.insert)// 对应数据表的字段，第二个参数告诉框架插入数据时需要调用填充方法自动填充内容
    private date createtime;

    @schema(description = "更新时间")
    @tablefield(value = "update_time",fill = fieldfill.update)// 第二个参数告诉框架更新数据时需要调用填充方法自动填充内容
    @jsonignore // 所有的返回值都不会返回这个值了
    private date updatetime;

	@tablelogic // 过滤逻辑删除，当请求查询时，会自动过滤掉is_deleted=1的已删除的数据，不会返回给前端
    @schema(description = "逻辑删除")
    @tablefield("is_deleted")
    private byte isdeleted;
}

@component
public class mybatismetaobjecthandler implements metaobjecthandler {
    @override
    public void insertfill(metaobject metaobject) {
        this.strictinsertfill(metaobject, "createtime", date.class, new date());
    }

    @override
    public void updatefill(metaobject metaobject) {
        this.strictupdatefill(metaobject, "updatetime", date.class, new date());
    }
}

@schema(description = "标签信息表") // 接口名称
@tablename(value = "label_info")// 数据库表的名称，指定使用该实体类时操作的数据库表
@data
public class labelinfo extends baseentity {

    private static final long serialversionuid = 1l;

    @schema(description = "类型")// 字段描述
    @tablefield(value = "type")// 对应数据表的字段
    private itemtype type;// 使用itemtype枚举类

    @schema(description = "标签名称")
    @tablefield(value = "name")
    private string name;

    // 当实体类不需要通用字段时，告诉 mybatis-plus 这个字段不存在于表
	// 方法一：
    @tablefield(exist = false)
    private date updatetime;
    // 方法二：也可以写在baseentity通用实体类上
    @jsonignore
    private long id;
}

public interface baseenum {
    integer getcode();
    string getname();
}

public enum itemtype implements baseenum {

    apartment(1, "公寓"),
    room(2, "房间");

    @enumvalue
    @jsonvalue
    private integer code;
    private string name;

    @override
    public integer getcode() {
        return this.code;// 返回{code:1}
    }
    @override
    public string getname() {
        return name; // 返回{name:"公寓"}
    }
    
	// 构造方法，给枚举类赋值
    itemtype(integer code, string name) {
        this.code = code;
        this.name = name;
    }
}

@component
// 接收两个参数，一个是前端传递string类型值，一个是枚举类的父接口
public class stringtobaseenumconverterfactory implements converterfactory<string, baseenum> {
    @override
    public <t extends baseenum> converter<string, t> getconverter(class<t> targettype) {
        return new converter<string, t>() {// 返回一个转换器
            @override
            public t convert(string source) {// source = 前端传来的字符串，比如 "1"
                /**
                 * 1. 遍历所有值继承baseenum接口的枚举类
                 * targettype.getenumconstants()：获取所有枚举类的值[apartment, room, deleted...]
                 */
                for (t enumconstant : targettype.getenumconstants()) {
                    // 2. 判断1如果前端传的code等于枚举的code不
                    if (enumconstant.getcode().equals(integer.valueof(source))) {
                        return enumconstant; // 返回对应的枚举对象
                    }
                }
                // 3. 找不到匹配的，抛异常
                throw new illegalargumentexception("非法的枚举值:" + source);
            }
        };
    }
}

@configuration
public class webmvcconfiguration implements webmvcconfigurer {

    @autowired
    private stringtobaseenumconverterfactory stringtobaseenumconverterfactory;

    @override
    public void addformatters(formatterregistry registry) {
        registry.addconverterfactory(this.stringtobaseenumconverterfactory);
    }
}

	@operation(summary = "（根据类型）查询标签列表")
    @getmapping("list")
    public result<list<labelinfo>> labellist(@requestparam(required = false) itemtype type) {}

public enum itemtype implements baseenum {

    apartment(1, "公寓"),
    room(2, "房间");

    @enumvalue
    private integer code;
    private string name;

    @override
    public integer getcode() {
        return this.code;
    }

    @override
    public string getname() {
        return name;
    }

    // 构造方法，给枚举类赋值
    itemtype(integer code, string name) {
        this.code = code;
        this.name = name;
    }
}

【查询响应】
数据库 → typehandler → 实体类(含枚举) → controller → httpmessageconverter → json → 前端

【保存请求】  
前端 → json → httpmessageconverter → controller → 实体类(含枚举) → typehandler → 数据库

public enum itemtype implements baseenum {

    apartment(1, "公寓"),
    room(2, "房间");

    @jsonvalue
    private integer code;
    private string name;

    @override
    public integer getcode() {
        return this.code;
    }

    @override
    public string getname() {
        return name;
    }

    // 构造方法，给枚举类赋值
    itemtype(integer code, string name) {
        this.code = code;
        this.name = name;
    }
}

@data
@schema(description = "公寓信息")// 类描述
public class apartmentdetailvo extends apartmentinfo {

    @schema(description = "图片列表")// 字段描述
    private list<graphvo> graphvolist;// 拿取之前写的vo类图片列表，新起字段为graphvolist

    @schema(description = "标签列表")
    private list<labelinfo> labelinfolist;// 拿取之前写的实体类标签列表，新起字段为labelinfolist
}

@restcontroller
@tag(name = "房间属性管理") // 定义接口所属模块名
@requestmapping("/admin/attr")// 接口根路径
public class attrcontroller {
    @autowired// 自动注入，可以理解为将attrkeyservice引入并赋值给attrkeyservice,不需要new对象了
    private attrkeyservice attrkeyservice;

	// 单表的简单增加和更新操作
    @operation(summary = "新增或更新属性名称")// 接口描述
    @postmapping("key/saveorupdate") // 接口路径名
    public result saveorupdateattrkey(@requestbody attrkey attrkey) {
        attrkeyservice.saveorupdate(attrkey);// 直接调用mybatis-plus内部的api进行操作
        return result.ok();
    }
    
    // 进行复杂查询
    @operation(summary = "查询全部属性名称和属性值列表")// 接口描述
    @getmapping("list")// 接口路径名
    public result<list<attrkeyvo>> listattrinfo() {
        // 调用attrkeyservice服务类里的方法listattrinfo进行操作
        list<attrkeyvo> list = attrkeyservice.listattrinfo();
        return result.ok(list);
    }
}

/**
* @author liubo
* @description 针对表【attr_key(房间基本属性表)】的数据库操作service
* @createdate 2023-07-24 15:48:00
*/
public interface attrkeyservice extends iservice<attrkey> {
    list<attrkeyvo> listattrinfo();
}

/**
* @author liubo
* @description 针对表【attr_key(房间基本属性表)】的数据库操作service实现
* @createdate 2023-07-24 15:48:00
*/
@service
public class attrkeyserviceimpl extends serviceimpl<attrkeymapper, attrkey> implements attrkeyservice{
    @autowired // 引入会在mapper下显示红线错误，这只是idea的错误，不影响运行
    private attrkeymapper mapper;

    @override
    public list<attrkeyvo> listattrinfo() {
    	// 一些复杂的功能逻辑也会在这里完成，比如登录接口验证，获取多表内容进行统计等
        list<attrkeyvo> attrkeyvos = mapper.listattrinfo(); // 调取相应的mapper接口方法
        return attrkeyvos;
    }
}

/**
* @author liubo
* @description 针对表【attr_key(房间基本属性表)】的数据库操作mapper
* @createdate 2023-07-24 15:48:00
* @entity com.lease.model.attrkey
*/
public interface attrkeymapper extends basemapper<attrkey> {
    list<attrkeyvo> listattrinfo();
}

<?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.lease.web.admin.mapper.attrkeymapper">
    <select id="listattrinfo" resultmap="baseresultmap">
       // 进行sql语句的编写
    </select>
</mapper>

@configuration
public class redisconfiguration {

    @bean
    public redistemplate<string, object> stringobjectredistemplate(redisconnectionfactory redisconnectionfactory) {
        redistemplate<string, object> template = new redistemplate<>();
        template.setconnectionfactory(redisconnectionfactory);
        template.setkeyserializer(redisserializer.string());
        template.setvalueserializer(redisserializer.java());
        return template;
    }
}

	@override
    public list<attrkeyvo> listattrinfo() {
        // 拼接redis的key
        string key = redisconstant.admin_login_prefix;
        // 查询redis里是否有该数据
        list<attrkeyvo> attrkeyvos = (list<attrkeyvo>) redistemplate.opsforvalue().get(key);
        // 判断，当redi没有对应数据时才到数据库里查询
        if(attrkeyvos == null){
        	// 查询数据
            attrkeyvos = mapper.listattrinfo();
            // 将查询的数据存入redis，并设置过期时间为12小时
            redistemplate.opsforvalue().set(key, attrkeyvos, 12, timeunit.hours);
        }
        return attrkeyvos;
    }

	@operation(summary = "新增或更新属性名称")// 接口描述
    @postmapping("key/saveorupdate") // 接口路径名
    public result saveorupdateattrkey(@requestbody attrkey attrkey) {
        boolean result = attrkeyservice.saveorupdate(attrkey);
        if (result) {
            // 清除属性列表缓存（因为 listattrinfo 包含属性值）
            string key = redisconstant.admin_login_prefix;
            redistemplate.delete(key);
        }
        return result.ok();
    }