1.请参见项目代码地址

文章目录

一.官方简介

1.官方文档地址

2.RuoYi-Vue是基于SpringBoot、Spring Security、MyBatis、Jwt、Vue的前后端分离的后台管理系统。

3.后端结构

com.ruoyi     
├── common            // 工具类
│       └── annotation                    // 自定义注解
│       └── config                        // 全局配置
│       └── constant                      // 通用常量
│       └── core                          // 核心控制
│       └── enums                         // 通用枚举
│       └── exception                     // 通用异常
│       └── filter                        // 过滤器处理
│       └── utils                         // 通用类处理
├── framework         // 框架核心
│       └── aspectj                       // 注解实现
│       └── config                        // 系统配置
│       └── datasource                    // 数据权限
│       └── interceptor                   // 拦截器
│       └── manager                       // 异步处理
│       └── security                      // 权限控制
│       └── web                           // 前端控制
├── ruoyi-generator   // 代码生成（可移除）
├── ruoyi-quartz      // 定时任务（可移除）
├── ruoyi-system      // 系统代码
├── ruoyi-admin       // 后台服务
├── ruoyi-xxxxxx      // 其他模块

二.基础框架搭建

2.1 搭建父工程ruoyi-vue-my

File—new—Project—选择Spring Initializ–next–填写Group和Artifact，Type选择POM–next–不选择依赖直接下一步(或者选你需要的都行，我这里不选择跳过)—finish。删除无用的目录及文件，比如src、.mvn、mvnw、mvnw.cmd等。在pom.xml中添加< packaging>pom< /packaging>

<?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>2.6.4</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.mashirro</groupId>
    <artifactId>ruoyi-vue-my</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ruoyi-vue-my</name>
    <description>后台管理系统</description>

    <packaging>pom</packaging>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- 远程仓库:
如果 Maven 在中央仓库中也找不到依赖的文件，它会停止构建过程并输出错误信息到控制台。
为避免这种情况，Maven 提供了远程仓库的概念，
它是开发人员自己定制仓库，包含了所需要的代码库或者其他工程中用到的 jar 文件。 -->
    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
    <pluginRepositories>
        <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素
        <pluginRepository></pluginRepository>
         -->
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>
2.2 搭建子工程ruoyi-common和ruoyi-framework和ruoyi-system(非web项目)

1.选中父项目ruoyi-vue右键—New–Module—选择maven—next—填写ArtifactId–next–finish。

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>ruoyi-vue</artifactId>
        <groupId>com.mashirro</groupId>
        <version>0.0.1-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>ruoyi-common</artifactId>
    <description>common通用工具</description>
</project>

2.ruoyi-system项目添加ruoyi-common依赖、ruoyiframework项目添加ruoyi-system依赖。在common模块的pom.xml中添加一些常用的工具类。

        <!-- JSON工具类 -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>
        <!--常用工具类 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
        </dependency>
        <!-- io常用工具类 -->
        <dependency>
            <groupId>commons-io</groupId>
            <artifactId>commons-io</artifactId>
            <version>2.11.0</version>
        </dependency>
        <!-- Hutool是一个小而全的Java工具类库 -->
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-all</artifactId>
            <version>5.7.22</version>
        </dependency>

3.父项目ruoyi-vue的pom.xml中添加

	<modules>
		<module>ruoyicommon</module>
		<module>ruoyiframework</module>
		<module>ruoyisystem</module>
	</modules>
2.3 搭建子工程ruoyi-admin(web项目)

1.选中父项目ruoyi-vue右键—New–Module–选择Spring Initializ–next–填写Group和Artifact，Type选择mavenproject–next–选个springweb依赖下一步。添加ruoyi-framework依赖。

<?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">
	<parent>
		<artifactId>ruoyi-vue-my</artifactId>
		<groupId>com.mashirro</groupId>
		<version>0.0.1-SNAPSHOT</version>
	</parent>
	<modelVersion>4.0.0</modelVersion>

	<artifactId>ruoyi-admin</artifactId>
	<description>web服务入口</description>

	<dependencies>
		<!-- 依赖framework模块 -->
		<dependency>
			<groupId>com.mashirro</groupId>
			<artifactId>ruoyi-framework</artifactId>
			<version>0.0.1-SNAPSHOT</version>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

2.父工程pom.xml添加module

2.4 依赖管理dependencyManagement

详见Maven中dependencyManagement作用说明
详见Spring Boot Maven 插件

1.修改父工程ruoyi-vue-my的pom.xml，并且将commons-io和hutool也改为依赖管理。

<?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>

    <groupId>com.mashirro</groupId>
    <artifactId>ruoyi-vue-my</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>ruoyi-vue-my</name>
    <description>后台管理系统</description>

    <packaging>pom</packaging>

    <modules>
        <module>ruoyicommon</module>
        <module>ruoyiframework</module>
        <module>ruoyisystem</module>
        <module>ruoyi-admin</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
        <commons.io.version>2.11.0</commons.io.version>
        <hutool.version>5.7.22</hutool.version>
    </properties>

    <!-- 依赖声明 -->
    <dependencyManagement>
        <dependencies>
            <!-- 如果您不想使用spring-boot-starter-parent，你仍然可以通过导入作用域依赖来保持依赖管理的好处(但不是插件管理) -->
            <dependency>
                <!-- Import dependency management from Spring Boot -->
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>2.6.4</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
           <!-- io常用工具类 -->
            <dependency>
                <groupId>commons-io</groupId>
                <artifactId>commons-io</artifactId>
                <version>${commons.io.version}</version>
            </dependency>
            <!-- Hutool是一个小而全的Java工具类库 -->
            <dependency>
                <groupId>cn.hutool</groupId>
                <artifactId>hutool-all</artifactId>
                <version>${hutool.version}</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.1</version>
                <configuration>
                    <source>${java.version}</source>
                    <target>${java.version}</target>
                    <encoding>${project.build.sourceEncoding}</encoding>
                </configuration>
            </plugin>
        </plugins>
    </build>

    <!-- 远程仓库:
如果 Maven 在中央仓库中也找不到依赖的文件，它会停止构建过程并输出错误信息到控制台。
为避免这种情况，Maven 提供了远程仓库的概念，
它是开发人员自己定制仓库，包含了所需要的代码库或者其他工程中用到的 jar 文件。 -->
    <repositories>
        <repository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
        </repository>
    </repositories>

    <!--发现插件的远程仓库列表，这些插件用于构建和报表 -->
    <pluginRepositories>
        <!--包含需要连接到远程插件仓库的信息.参见repositories/repository元素
        <pluginRepository></pluginRepository>
         -->
        <pluginRepository>
            <id>public</id>
            <name>aliyun nexus</name>
            <url>https://maven.aliyun.com/repository/public</url>
            <releases>
                <enabled>true</enabled>
            </releases>
            <snapshots>
                <enabled>false</enabled>
            </snapshots>
        </pluginRepository>
    </pluginRepositories>
</project>

2.这种依赖关系管理允许您在自己的POM中使用时省略这些依赖关系的version标记。

2.5 引入数据库驱动以及mybatis以及分页插件等。编写一个基本的增删改查

1.在父工程pom.xml添加依赖管理声明

	<properties>
		<pagehelper.boot.version>1.4.1</pagehelper.boot.version>
	</properties>
	<!-- 依赖声明 -->
	<dependencyManagement>
		<dependencies>
			...
			<!-- pagehelper分页插件:包含了mybatis-spring-boot-starter -->
			<!-- mybatis-spring-boot-starter又包含了spring-boot-starter-jdbc -->
			<dependency>
				<groupId>com.github.pagehelper</groupId>
				<artifactId>pagehelper-spring-boot-starter</artifactId>
				<version>${pagehelper.boot.version}</version>
			</dependency>
		</dependencies>
	</dependencyManagement>

2.在ruoyicommon中添加依赖。

<!-- Mysql驱动包 -->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
        <!-- pagehelper分页插件:包含了mybatis-spring-boot-starter -->
        <!-- mybatis-spring-boot-starter又包含了spring-boot-starter-jdbc -->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
        </dependency>

3.在ruoyicommon和ruoyiframework和ruoyisystem添加父包com.mashirro.xxx。在common工程中编写统一结果返回类AjaxResult和状态码常量类HttpStatus。

/**
 * 操作消息提醒
 */
public class AjaxResult extends HashMap<String, Object> {
    private static final long serialVersionUID = 1L;

    /**
     * 状态码
     */
    public static final String CODE_TAG = "code";

    /**
     * 返回内容
     */
    public static final String MSG_TAG = "msg";

    /**
     * 数据对象
     */
    public static final String DATA_TAG = "data";

    /**
     * 初始化一个新创建的 AjaxResult 对象，使其表示一个空消息。
     */
    public AjaxResult() {
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     * @param code 状态码
     * @param msg  返回内容
     */
    public AjaxResult(int code, String msg) {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
    }

    /**
     * 初始化一个新创建的 AjaxResult 对象
     * @param code 状态码
     * @param msg  返回内容
     * @param data 数据对象
     */
    public AjaxResult(int code, String msg, Object data) {
        super.put(CODE_TAG, code);
        super.put(MSG_TAG, msg);
        if (data != null) {
            super.put(DATA_TAG, data);
        }
    }

    /**
     * 返回成功消息
     * @return 成功消息
     */
    public static AjaxResult success() {
        return AjaxResult.success("操作成功");
    }

    /**
     * 返回成功数据
     * @return 成功消息
     */
    public static AjaxResult success(Object data) {
        return AjaxResult.success("操作成功", data);
    }

    /**
     * 返回成功消息
     * @param msg 返回内容
     * @return 成功消息
     */
    public static AjaxResult success(String msg) {
        return AjaxResult.success(msg, null);
    }

    /**
     * 返回成功消息
     * @param msg  返回内容
     * @param data 数据对象
     * @return 成功消息
     */
    public static AjaxResult success(String msg, Object data) {
        return new AjaxResult(HttpStatus.SUCCESS, msg, data);
    }

    /**
     * 返回错误消息
     * @return
     */
    public static AjaxResult error() {
        return AjaxResult.error("操作失败");
    }

    /**
     * 返回错误消息
     * @param msg 返回内容
     * @return 警告消息
     */
    public static AjaxResult error(String msg) {
        return AjaxResult.error(msg, null);
    }

    /**
     * 返回错误消息
     * @param msg  返回内容
     * @param data 数据对象
     * @return 警告消息
     */
    public static AjaxResult error(String msg, Object data) {
        return new AjaxResult(HttpStatus.ERROR, msg, data);
    }

    /**
     * 返回错误消息
     * @param code 状态码
     * @param msg  返回内容
     * @return 警告消息
     */
    public static AjaxResult error(int code, String msg) {
        return new AjaxResult(code, msg, null);
    }

    /**
     * 方便链式调用
     * @param key   键
     * @param value 值
     * @return 数据对象
     */
    @Override
    public AjaxResult put(String key, Object value) {
        super.put(key, value);
        return this;
    }
}

/**
 * 返回状态码
 */
public class HttpStatus {
    /**
     * 操作成功
     */
    public static final int SUCCESS = 200;

    /**
     * 对象创建成功
     */
    public static final int CREATED = 201;

    /**
     * 请求已经被接受
     */
    public static final int ACCEPTED = 202;

    /**
     * 操作已经执行成功，但是没有返回数据
     */
    public static final int NO_CONTENT = 204;

    /**
     * 资源已被移除
     */
    public static final int MOVED_PERM = 301;

    /**
     * 重定向
     */
    public static final int SEE_OTHER = 303;

    /**
     * 资源没有被修改
     */
    public static final int NOT_MODIFIED = 304;

    /**
     * 参数列表错误（缺少，格式不匹配）
     */
    public static final int BAD_REQUEST = 400;

    /**
     * 未授权
     */
    public static final int UNAUTHORIZED = 401;

    /**
     * 访问受限，授权过期
     */
    public static final int FORBIDDEN = 403;

    /**
     * 资源，服务未找到
     */
    public static final int NOT_FOUND = 404;

    /**
     * 不允许的http方法
     */
    public static final int BAD_METHOD = 405;

    /**
     * 资源冲突，或者资源被锁
     */
    public static final int CONFLICT = 409;

    /**
     * 不支持的数据，媒体类型
     */
    public static final int UNSUPPORTED_TYPE = 415;

    /**
     * 系统内部错误
     */
    public static final int ERROR = 500;

    /**
     * 接口未实现
     */
    public static final int NOT_IMPLEMENTED = 501;
}

4.编写通用的BaseController来处理分页等通用数据处理，需要获取request来获取分页参数。我们需要在common中添加servlet依赖和spring web依赖，编写ServletUtils工具类。还需要编写表格分页数据对象TableDataInfo类。

        <!-- SpringWeb模块 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
        </dependency>
        <!-- servlet包 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <!-- provided:很像compile，但表示您希望JDK或容器在运行时提供它。它仅在编译和测试类路径上可用，不可传递。-->
            <scope>provided</scope>
        </dependency>

/**
 * 客户端工具类
 */
public class ServletUtils {
    /**
     * 获取String参数
     */
    public static String getParameter(String name) {
        return getRequest().getParameter(name);
    }

    /**
     * 获取String参数
     */
    public static String getParameter(String name, String defaultValue) {
        return Convert.toStr(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name) {
        return Convert.toInt(getRequest().getParameter(name));
    }

    /**
     * 获取Integer参数
     */
    public static Integer getParameterToInt(String name, Integer defaultValue) {
        return Convert.toInt(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 获取Boolean参数
     */
    public static Boolean getParameterToBool(String name) {
        return Convert.toBool(getRequest().getParameter(name));
    }

    /**
     * 获取Boolean参数
     */
    public static Boolean getParameterToBool(String name, Boolean defaultValue) {
        return Convert.toBool(getRequest().getParameter(name), defaultValue);
    }

    /**
     * 获取request
     */
    public static HttpServletRequest getRequest() {
        return getRequestAttributes().getRequest();
    }

    /**
     * 获取response
     */
    public static HttpServletResponse getResponse() {
        return getRequestAttributes().getResponse();
    }

    /**
     * 获取session
     */
    public static HttpSession getSession() {
        return getRequest().getSession();
    }

    public static ServletRequestAttributes getRequestAttributes() {
        RequestAttributes attributes = RequestContextHolder.getRequestAttributes();
        return (ServletRequestAttributes) attributes;
    }
}

//表格分页数据对象
public class TableDataInfo implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 总记录数
     */
    private long total;

    /**
     * 列表数据
     */
    private List<?> rows;

    /**
     * 消息状态码
     */
    private int code;

    /**
     * 消息内容
     */
    private String msg;

    /**
     * 表格数据对象
     */
    public TableDataInfo() {
    }

    /**
     * 分页
     * @param list  列表数据
     * @param total 总记录数
     */
    public TableDataInfo(List<?> list, int total) {
        this.rows = list;
        this.total = total;
    }

    public long getTotal() {
        return total;
    }

    public void setTotal(long total) {
        this.total = total;
    }

    public List<?> getRows() {
        return rows;
    }

    public void setRows(List<?> rows) {
        this.rows = rows;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

5.在ruoyicommon模块中编写BaseController web层通用数据处理：(1)请求分页数据及分页(2)响应请求分页数据。

/**
 * web层通用数据处理
 */
public class BaseController {
    /**
     * 当前记录起始索引
     */
    private static final String PAGE_NUM = "pageNum";

    /**
     * 每页显示记录数
     */
    private static final String PAGE_SIZE = "pageSize";

    //请求分页数据及分页
    protected void startPage() {
        Integer pageNum = ServletUtils.getParameterToInt(PAGE_NUM);
        Integer pageSize = ServletUtils.getParameterToInt(PAGE_SIZE);
        if (pageNum != null && pageSize != null) {
            PageHelper.startPage(pageNum, pageSize);
        }
    }

    //响应请求分页数据
    protected <T> TableDataInfo getDataTable(List<T> list) {
        //用PageInfo对结果进行包装,PageInfo包含了非常全面的分页属性
        PageInfo<T> pageInfo = new PageInfo<T>(list);
        TableDataInfo res = new TableDataInfo();
        res.setCode(HttpStatus.SUCCESS);
        res.setMsg("查询成功");
        res.setRows(list);
        res.setTotal(pageInfo.getTotal());
        return res;
    }
}

6.在ruoyicommon中编写SysUser实体类和BaseEntity基础实体类(因为我们需要用到 @JsonFormat格式化时间所以我们之前已在common中引入jackson-databind依赖)。在ruoyi-admin中编写SysUserController控制器，在ruoyisystem中编写ISysUserService接口以及实现类以及mapper接口。

/**
 * Entity基类
 */
public class BaseEntity implements Serializable{
    private static final long serialVersionUID = 2270519270996881518L;
    /** 创建者 */
    private String createBy;
    /** 创建时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date createTime;
    /** 更新者 */
    private String updateBy;
    /** 更新时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date updateTime;
    /** 请求参数 */
    private Map<String, Object> params;
    //......省略getter和setter
    public Map<String, Object> getParams() {
        if (params == null) {
            params = new HashMap<>();
        }
        return params;
    }
}

/**
 * 用户对象 sys_user
 */
public class SysUser extends BaseEntity{
    private static final long serialVersionUID = -5517452056588910565L;
    /** 用户ID */
    private Long userId;
    /** 部门ID */
    private Long deptId;
    /** 用户账号 */
    private String userName;
    /** 用户昵称 */
    private String nickName;
    /** 用户类型（00系统用户）*/
    private String userType;
    /** 用户邮箱 */
    private String email;
    /** 手机号码 */
    private String phonenumber;
    /** 用户性别 */
    private String sex;
    /** 用户头像 */
    private String avatar;
    /** 密码 */
    private String password;
    /** 帐号状态（0正常 1停用） */
    private String status;
    /** 删除标志（0代表存在 2代表删除） */
    private String delFlag;
    /** 最后登录IP */
    private String loginIp;
    /** 最后登录时间 */
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    private Date loginDate;
    /** 备注 */
    private String remark;
    //....省略getter和setter
}

/**
 * 用户信息
 */
@RestController
@RequestMapping("/system/user")
public class SysUserController extends BaseController {
    @Autowired
    private ISysUserService userService;
    /**
     * 获取用户列表
     * 请求地址:http://localhost:8088/system/user/list?pageNum=1&pageSize=10&params%5BbeginTime%5D=2020-01-01&params%5BendTime%5D=2022-01-01
     */
    @GetMapping("/list")
    public TableDataInfo list(SysUser user) {
        startPage();
        List<SysUser> list = userService.selectUserList(user);
        return getDataTable(list);
    }
}

/**
 * 用户 业务层
 */
public interface ISysUserService {
    /**
     * 根据条件分页查询用户列表
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    public List<SysUser> selectUserList(SysUser user);
}

/**
 * 用户 业务层处理
 */
@Service
public class SysUserServiceImpl implements ISysUserService {
    private static final Logger log = LoggerFactory.getLogger(SysUserServiceImpl.class);
    @Autowired
    private SysUserMapper userMapper;
    /**
     * 根据条件分页查询用户列表
     * @param user 用户信息
     * @return 用户信息集合信息
     */
    @Override
    public List<SysUser> selectUserList(SysUser user) {
        return userMapper.selectUserList(user);
    }
}


/**
 * 用户表 数据层
 */
public interface SysUserMapper {
    /**
     * 根据条件分页查询用户列表
     * @param sysUser 用户信息
     * @return 用户信息集合信息
     */
    public List<SysUser> selectUserList(SysUser sysUser);
}

<resultMap type="com.mashirro.common.domain.SysUser" id="SysUserResult">
		<id     property="userId"       column="user_id"      />
		<result property="deptId"       column="dept_id"      />
		<result property="userName"     column="user_name"    />
		<result property="nickName"     column="nick_name"    />
		<result property="email"        column="email"        />
		<result property="phonenumber"  column="phonenumber"  />
		<result property="sex"          column="sex"          />
		<result property="avatar"       column="avatar"       />
		<result property="password"     column="password"     />
		<result property="status"       column="status"       />
		<result property="delFlag"      column="del_flag"     />
		<result property="loginIp"      column="login_ip"     />
		<result property="loginDate"    column="login_date"   />
		<result property="remark"       column="remark"       />
		<result property="createBy"     column="create_by"    />
		<result property="createTime"   column="create_time"  />
		<result property="updateBy"     column="update_by"    />
		<result property="updateTime"   column="update_time"  />
	</resultMap>


    <select id="selectUserList" parameterType="com.mashirro.common.domain.SysUser" resultMap="SysUserResult">
		select u.user_id, u.dept_id, u.nick_name, u.user_name, u.email, u.avatar, u.phonenumber, u.password, u.sex, u.status, u.del_flag, u.login_ip, u.login_date, u.create_by, u.create_time, u.remark, d.dept_name, d.leader from sys_user u
		left join sys_dept d on u.dept_id = d.dept_id
		where u.del_flag = '0'
		<if test="userId != null and userId != 0">
			AND u.user_id = #{userId}
		</if>
		<if test="userName != null and userName != ''">
			AND u.user_name like concat('%', #{userName}, '%')
		</if>
		<if test="status != null and status != ''">
			AND u.status = #{status}
		</if>
		<if test="phonenumber != null and phonenumber != ''">
			AND u.phonenumber like concat('%', #{phonenumber}, '%')
		</if>
		<if test="params.beginTime != null and params.beginTime != ''"><!-- 开始时间检索 -->
			AND date_format(u.create_time,'%y%m%d') &gt;= date_format(#{params.beginTime},'%y%m%d')
		</if>
		<if test="params.endTime != null and params.endTime != ''"><!-- 结束时间检索 -->
			AND date_format(u.create_time,'%y%m%d') &lt;= date_format(#{params.endTime},'%y%m%d')
		</if>
		<if test="deptId != null and deptId != 0">
			AND (u.dept_id = #{deptId} OR u.dept_id IN ( SELECT t.dept_id FROM sys_dept t WHERE find_in_set(#{deptId}, ancestors) ))
		</if>
	</select>
2.6 编写ruoyi-admin的配置文件application.properties和mybatis全局配置文件mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- 全局参数 -->
    <settings>
        <!-- 使全局的映射器启用或禁用缓存 -->
        <setting name="cacheEnabled"             value="true"   />
        <!-- 允许JDBC 支持自动生成主键 -->
        <setting name="useGeneratedKeys"         value="true"   />
        <!-- 配置默认的执行器.SIMPLE就是普通执行器;REUSE执行器会重用预处理语句(prepared statements);BATCH执行器将重用语句并执行批量更新 -->
        <setting name="defaultExecutorType"      value="SIMPLE" />
		<!-- 指定 MyBatis 所用日志的具体实现 -->
        <setting name="logImpl"                  value="SLF4J"  />
        <!-- 使用驼峰命名法转换字段 -->
		<!-- <setting name="mapUnderscoreToCamelCase" value="true"/> -->
	</settings>
</configuration>

##Spring配置
#要激活某个profile，需要做的事就是将profile名称的列表赋值给spring.profiles.active属性。
spring.profiles.active=datasource

##开发环境配置
#服务器的HTTP端口
server.port=8080
#应用的访问路径
server.servlet.context-path=/

##日志配置
logging.level.com.mashirro=debug
logging.level.org.springframework=warn

##数据源配置
#1.使用最新的mysql连接驱动;2.访问数据库时无法识别时区(在中国可以选择Asia/Shanghai或者Asia/Hongkong,UTC会比中国时间早8个小时)
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://82.156.204.179:3306/ruoyi_vue?useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=zaq12wsx
#SpringBoot默认数据源 HikariDataSource
spring.datasource.type=com.zaxxer.hikari.HikariDataSource
##Hikari连接池配置 ------> 详细配置请访问：https://github.com/brettwooldridge/HikariCP
#此属性控制从池返回的连接的默认事务隔离级别。如果未指定此属性，则使用JDBC驱动程序定义的默认事务隔离级别。
#spring.datasource.hikari.transaction-isolation=
#此属性控制HikariCP尝试在池中维护的最小空闲连接数。如果空闲连接低于此值，并且池中的总连接数小于maximumPoolSize，HikariCP将尽最大努力快速高效地添加其他连接。但是，为了获得最佳性能和响应峰值需求，我们建议不要设置此值，而是允许HikariCP充当固定大小的连接池。默认值：与maximumPoolSize相同
spring.datasource.hikari.minimum-idle=5
#这是在从池向您提供连接之前执行的查询，以验证与数据库的连接是否仍处于活动状态
spring.datasource.hikari.connection-test-query=SELECT 1 FROM DUAL
#此属性控制池允许达到的最大大小，包括空闲连接和正在使用的连接。基本上，该值将确定到数据库后端的实际连接的最大数量。
spring.datasource.hikari.maximum-pool-size=20
#此属性控制从池返回的连接的默认自动提交行为。
spring.datasource.hikari.auto-commit=true
#此属性控制允许连接在池中处于空闲状态的最长时间。此设置仅适用于定义为小于maximumPoolSize的MinimumMidle。一旦池达到最小连接数，空闲连接将不会失效。
spring.datasource.hikari.idle-timeout=30000
#此属性表示连接池的用户定义名称，主要出现在日志和JMX管理控制台中，用于标识池和池配置
spring.datasource.hikari.pool-name=MyHikariCP
#此属性控制池中连接的最大生存期。正在使用的连接永远不会失效，只有当它关闭时才会被删除
spring.datasource.hikari.max-lifetime=60000
#此属性控制客户端（即您）等待池连接的最大毫秒数。如果在连接不可用的情况下超过此时间，将抛出SQLException。
spring.datasource.hikari.connection-timeout=30000


##mybatis相关配置
#配置mapper映射xml路径(*通配符)
mybatis.mapper-locations=classpath*:/mapper/*.xml
#加载全局的配置文件
mybatis.config-location=classpath:mybatis/mybatis-config.xml
#别名
#mybatis.type-aliases-package=com.mashirro.**.domain


##PageHelper分页插件配置(请参看官方文档https://pagehelper.github.io/docs/)
#分页插件会自动检测当前的数据库链接，自动选择合适的分页方式。 你可以配置helperDialect属性来指定分页插件使用哪种方言。
pagehelper.helper-dialect=mysql
#分页合理化参数，默认值为false。当该参数设置为true时，pageNum<=0 时会查询第一页，pageNum>pages（超过总数时），会查询最后一页。默认false 时，直接根据参数进行查询。
pagehelper.reasonable=true
#为了支持startPage(Object params)方法，增加了该参数来配置参数映射，用于从对象中根据属性名取值，可以配置 pageNum,pageSize,count,pageSizeZero,reasonable，不配置映射的用默认值，默认值为pageNum=pageNum;pageSize=pageSize;count=countSql;reasonable=reasonable;pageSizeZero=pageSizeZero
pagehelper.params=count=countSql
#支持通过Mapper接口参数来传递分页参数，默认值false，分页插件会从查询方法的参数值中，自动根据上面params配置的字段中取值，查找到合适的值时就会自动分页。
pagehelper.support-methods-arguments=true
2.7 启动ruoyi-admin的启动类RuoyiAdminApplication并使用postmen进行测试

省略

三 项目中遇到的问题

3.1 Spring boot多模块项目启动报错:(1)找不到service(2)找不到mapper

在这里插入图片描述
在这里插入图片描述

3.2 postmen请求报错400

解决方法：postman URL中如果含特殊字符，需要进行URL编码。

[ = %5B
] = %5D

在这里插入图片描述

# spring boot
Logo
欢迎使用若依开源

快速构建 Web 应用程序

更多推荐

eclipse安装若依框架

1、首先下载maven，下载地址为：http://maven.apache.org/download.cgi，然后选择apache-maven-3.6.0-bin.tar.gz，如下图所示：2、然后新建一个maven目录，如下图所示：3、将下载的maven包解压到该目录中，（注意此时maven的位置，与压缩包的位置相同）如下图所示：4、配置环境变量，新建一个MAVEN_HOME，值为：D:\...

avatar RuoYi 若依

开源框架若依实战Demo学习笔记

若依是个不错的框架，下面是我用他写的一个简单demo，以后会在此基础上进行进一步的开发，下面是整合的过程。我在整合的过程中可谓是一波三折，大家如果不想走弯路，那么这篇文章将对你很有帮助。首先，项目代码地址写列出来，方便大家下载使用，这是整理后的代码https://gitee.com/schjava/heros_separ.git启动项目访问localhost（默认80端口）配置测试用户先创建角色为

avatar RuoYi 若依
cover

docker compose完成简单项目部署

avatar RuoYi 若依