若依RuoYi-Vue三层架构

别喝凉水容易凉

已于 2023-08-16 10:44:17 修改

阅读量871

点赞数 3

分类专栏： RuoYi-Vue 文章标签： vue.js 前端 javascript

于 2023-08-15 18:03:39 首次发布

本文链接：https://blog.csdn.net/weixin_55047679/article/details/132304318

版权

RuoYi-Vue 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

什么是三层架构

三层架构就是把整个软件系统分为三个层次

表现层

Presentation layer

主要是用于接收用户输入的数据和显示处理后用户需要的数据。用户通过界面输入查询数据和得到需要的数据。

业务逻辑层

Business Logic Layer

主要是从数据库中得到数据然后对数据进行逻辑处理。比如修改某数据后同时需要修改所关联的另一个表中的数据

数据访问层

Data access layer

直接和数据库打交道的，对数据进行“增、删、改、查”等基本的操作。

为什么要分层？

方便团队分工，一个程序员单独完成一个软件产品不是不可以，但遇到大型软件需要团队配合的时候问题就来了，由于每个程序员风格不一样，而开发软件大量的代码风格不统一就会造成后期调试和维护出现问题，然而软件分层后，每个层合理分工这样的问题便迎刃而解。
规范代码，在开发软件时对每个层的代码进行规范，固定开发语言的风格。
忽略数据库差异，当软件系统要换数据库时，只要将数据访问层的代码修改就好了。
实现"高内聚、低耦合"。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。

三层架构之间如何联系起来？

一般来说都是通过实体层（entity layer）贯穿三个层次之间。实体层不属于三层架构中的任意一层。

若依代码生成中的架构

以生成MtSite代码为例

前端

v-haspermi 是一个基于 Vue.js 的权限管理插件,可以帮助开发者轻松实现前端权限管理。其主要作用是通过对用户角色和权限的定义和管理,实现对应页面或组件的访问控制。

根据角色拥有的权限控制页面中的操作按钮

表现层

MtSiteController

package com.ruoyi.web.controller.reservation;

import java.util.List;
import javax.servlet.http.HttpServletResponse;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.enums.BusinessType;
import com.ruoyi.reservation.domain.MtSite;
import com.ruoyi.reservation.service.IMtSiteService;
import com.ruoyi.common.utils.poi.ExcelUtil;
import com.ruoyi.common.core.page.TableDataInfo;

/**
 * 预约场地Controller
 *
 * @author mt
 * @date 2023-07-31
 */
@RestController
@RequestMapping("/reservation/site")
public class MtSiteController extends BaseController
{
    @Autowired
    private IMtSiteService mtSiteService;

    /**
     * 查询预约场地列表
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:list')")
    @GetMapping("/list")
    public TableDataInfo list(MtSite mtSite)
    {
        startPage();
        List<MtSite> list = mtSiteService.selectMtSiteList(mtSite);
        return getDataTable(list);
    }

    /**
     * 导出预约场地列表
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:export')")
    @Log(title = "预约场地", businessType = BusinessType.EXPORT)
    @PostMapping("/export")
    public void export(HttpServletResponse response, MtSite mtSite)
    {
        List<MtSite> list = mtSiteService.selectMtSiteList(mtSite);
        ExcelUtil<MtSite> util = new ExcelUtil<MtSite>(MtSite.class);
        util.exportExcel(response, list, "预约场地数据");
    }

    /**
     * 获取预约场地详细信息
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:query')")
    @GetMapping(value = "/{siteId}")
    public AjaxResult getInfo(@PathVariable("siteId") Long siteId)
    {
        return success(mtSiteService.selectMtSiteBySiteId(siteId));
    }

    /**
     * 新增预约场地
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:add')") //自定义权限，在方法执行前进行权限验证
    @Log(title = "预约场地", businessType = BusinessType.INSERT) //记录接口的操作信息 businessType:业务类型
    @PostMapping//PostMapping+AjaxResult优化数据传输模块,
    public AjaxResult add(@RequestBody MtSite mtSite)
    {
        return toAjax(mtSiteService.insertMtSite(mtSite));
    }
    //AjaxResult 继承了 HashMap<String, Object>，其对象实例化后，可以插入复杂数据，例如 Json格式数据

    /**
     * 修改预约场地
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:edit')")
    @Log(title = "预约场地", businessType = BusinessType.UPDATE)
    @PutMapping
    public AjaxResult edit(@RequestBody MtSite mtSite)
    {
        return toAjax(mtSiteService.updateMtSite(mtSite));
    }

    /**
     * 删除预约场地
     */
    @PreAuthorize("@ss.hasPermi('reservation:site:remove')")
    @Log(title = "预约场地", businessType = BusinessType.DELETE)
	@DeleteMapping("/{siteIds}")
    public AjaxResult remove(@PathVariable Long[] siteIds)
    {
        return toAjax(mtSiteService.deleteMtSiteBySiteIds(siteIds));
    }
}

@PreAuthorize注解

@PreAuthorize注解会在方法执行前进行权限验证，是基于方法注解的权限解决方案。

@PreAuthorize("@ss.hasPermi('reservation:site:add')")

@Log

自定义操作日志记录注解

title：标题，一般就是用来说明这个操作是干嘛的，例如删除一个用户

business_type：业务类型，一般来说有：添加、修改、删除、导入、导出等

@RequestMapping

请求注解	请求方式
@RequestMapping	GET	获取数据，类似于数据库中的select
@PutMapping	PUT	发送数据，类似于数据库的insert操作
@PostMapping	POST	发送数据，类似于数据库的update操作
@DeleteMapping	DELETE	删除数据，类似于数据库中的delete操作

业务逻辑层

IMtSiteService

package com.ruoyi.reservation.service;

import java.util.List;
import com.ruoyi.reservation.domain.MtSite;

/**
 * 预约场地Service接口
 * 
 * @author mt
 * @date 2023-07-31
 */
public interface IMtSiteService 
{
    /**
     * 查询预约场地
     * 
     * @param siteId 预约场地主键
     * @return 预约场地
     */
    public MtSite selectMtSiteBySiteId(Long siteId);

    /**
     * 查询预约场地列表
     * 
     * @param mtSite 预约场地
     * @return 预约场地集合
     */
    public List<MtSite> selectMtSiteList(MtSite mtSite);

    /**
     * 新增预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    public int insertMtSite(MtSite mtSite);

    /**
     * 修改预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    public int updateMtSite(MtSite mtSite);

    /**
     * 批量删除预约场地
     * 
     * @param siteIds 需要删除的预约场地主键集合
     * @return 结果
     */
    public int deleteMtSiteBySiteIds(Long[] siteIds);

    /**
     * 删除预约场地信息
     * 
     * @param siteId 预约场地主键
     * @return 结果
     */
    public int deleteMtSiteBySiteId(Long siteId);
}

MtSiteServiceImpl

package com.ruoyi.reservation.service.impl;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.ruoyi.reservation.mapper.MtSiteMapper;
import com.ruoyi.reservation.domain.MtSite;
import com.ruoyi.reservation.service.IMtSiteService;

/**
 * 预约场地Service业务层处理
 * 
 * @author mt
 * @date 2023-07-31
 */
@Service
public class MtSiteServiceImpl implements IMtSiteService 
{
    @Autowired
    private MtSiteMapper mtSiteMapper;

    /**
     * 查询预约场地
     * 
     * @param siteId 预约场地主键
     * @return 预约场地
     */
    @Override
    public MtSite selectMtSiteBySiteId(Long siteId)
    {
        return mtSiteMapper.selectMtSiteBySiteId(siteId);
    }

    /**
     * 查询预约场地列表
     * 
     * @param mtSite 预约场地
     * @return 预约场地
     */
    @Override
    public List<MtSite> selectMtSiteList(MtSite mtSite)
    {
        return mtSiteMapper.selectMtSiteList(mtSite);
    }

    /**
     * 新增预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    @Override
    public int insertMtSite(MtSite mtSite)
    {
        return mtSiteMapper.insertMtSite(mtSite);
    }

    /**
     * 修改预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    @Override
    public int updateMtSite(MtSite mtSite)
    {
        return mtSiteMapper.updateMtSite(mtSite);
    }

    /**
     * 批量删除预约场地
     * 
     * @param siteIds 需要删除的预约场地主键
     * @return 结果
     */
    @Override
    public int deleteMtSiteBySiteIds(Long[] siteIds)
    {
        return mtSiteMapper.deleteMtSiteBySiteIds(siteIds);
    }

    /**
     * 删除预约场地信息
     * 
     * @param siteId 预约场地主键
     * @return 结果
     */
    @Override
    public int deleteMtSiteBySiteId(Long siteId)
    {
        return mtSiteMapper.deleteMtSiteBySiteId(siteId);
    }
}

数据访问层

MtSiteMapper

package com.ruoyi.reservation.mapper;

import java.util.List;
import com.ruoyi.reservation.domain.MtSite;

/**
 * 预约场地Mapper接口
 * 
 * @author mt
 * @date 2023-07-31
 */
public interface MtSiteMapper 
{
    /**
     * 查询预约场地
     * 
     * @param siteId 预约场地主键
     * @return 预约场地
     */
    public MtSite selectMtSiteBySiteId(Long siteId);

    /**
     * 查询预约场地列表
     * 
     * @param mtSite 预约场地
     * @return 预约场地集合
     */
    public List<MtSite> selectMtSiteList(MtSite mtSite);

    /**
     * 新增预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    public int insertMtSite(MtSite mtSite);

    /**
     * 修改预约场地
     * 
     * @param mtSite 预约场地
     * @return 结果
     */
    public int updateMtSite(MtSite mtSite);

    /**
     * 删除预约场地
     * 
     * @param siteId 预约场地主键
     * @return 结果
     */
    public int deleteMtSiteBySiteId(Long siteId);

    /**
     * 批量删除预约场地
     * 
     * @param siteIds 需要删除的数据主键集合
     * @return 结果
     */
    public int deleteMtSiteBySiteIds(Long[] siteIds);
}

MtSiteMapper.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.ruoyi.reservation.mapper.MtSiteMapper">
    
    <resultMap type="MtSite" id="MtSiteResult">
        <result property="siteId"    column="site_id"    />
        <result property="siteCampus"    column="site_Campus"    />
        <result property="siteFloor"    column="site_floor"    />
        <result property="siteRegion"    column="site_region"    />
        <result property="siteClassroom"    column="site_classroom"    />
        <result property="siteMax"    column="site_max"    />
    </resultMap>

    <sql id="selectMtSiteVo">
        select site_id, site_Campus, site_floor, site_region, site_classroom, site_max from mt_site
    </sql>

    <select id="selectMtSiteList" parameterType="MtSite" resultMap="MtSiteResult">
        <include refid="selectMtSiteVo"/>
        <where>  
            <if test="siteCampus != null  and siteCampus != ''"> and site_Campus = #{siteCampus}</if>
            <if test="siteFloor != null  and siteFloor != ''"> and site_floor = #{siteFloor}</if>
            <if test="siteClassroom != null  and siteClassroom != ''"> and site_classroom = #{siteClassroom}</if>
        </where>
    </select>
    
    <select id="selectMtSiteBySiteId" parameterType="Long" resultMap="MtSiteResult">
        <include refid="selectMtSiteVo"/>
        where site_id = #{siteId}
    </select>
        
    <insert id="insertMtSite" parameterType="MtSite" useGeneratedKeys="true" keyProperty="siteId">
        insert into mt_site
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="siteCampus != null">site_Campus,</if>
            <if test="siteFloor != null">site_floor,</if>
            <if test="siteRegion != null">site_region,</if>
            <if test="siteClassroom != null">site_classroom,</if>
            <if test="siteMax != null">site_max,</if>
         </trim>
        <trim prefix="values (" suffix=")" suffixOverrides=",">
            <if test="siteCampus != null">#{siteCampus},</if>
            <if test="siteFloor != null">#{siteFloor},</if>
            <if test="siteRegion != null">#{siteRegion},</if>
            <if test="siteClassroom != null">#{siteClassroom},</if>
            <if test="siteMax != null">#{siteMax},</if>
         </trim>
    </insert>

    <update id="updateMtSite" parameterType="MtSite">
        update mt_site
        <trim prefix="SET" suffixOverrides=",">
            <if test="siteCampus != null">site_Campus = #{siteCampus},</if>
            <if test="siteFloor != null">site_floor = #{siteFloor},</if>
            <if test="siteRegion != null">site_region = #{siteRegion},</if>
            <if test="siteClassroom != null">site_classroom = #{siteClassroom},</if>
            <if test="siteMax != null">site_max = #{siteMax},</if>
        </trim>
        where site_id = #{siteId}
    </update>

    <delete id="deleteMtSiteBySiteId" parameterType="Long">
        delete from mt_site where site_id = #{siteId}
    </delete>

    <delete id="deleteMtSiteBySiteIds" parameterType="String">
        delete from mt_site where site_id in 
        <foreach item="siteId" collection="array" open="(" separator="," close=")">
            #{siteId}
        </foreach>
    </delete>
</mapper>

实体层

还有一个贯穿始终的实体层：

MtSite

package com.ruoyi.reservation.domain;

import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.core.domain.BaseEntity;

/**
 * 预约场地对象 mt_site
 * 
 * @author mt
 * @date 2023-07-31
 */
public class MtSite extends BaseEntity
{
    private static final long serialVersionUID = 1L;

    /** id */
    private Long siteId;

    /** 校区 */
    @Excel(name = "校区")
    private String siteCampus;

    /** 楼宇 */
    @Excel(name = "楼宇")
    private String siteFloor;

    /** 区域 */
    @Excel(name = "区域")
    private String siteRegion;

    /** 教室 */
    @Excel(name = "教室")
    private String siteClassroom;

    /** 最大容纳人数 */
    @Excel(name = "最大容纳人数")
    private Long siteMax;

    public void setSiteId(Long siteId) 
    {
        this.siteId = siteId;
    }

    public Long getSiteId() 
    {
        return siteId;
    }
    public void setSiteCampus(String siteCampus) 
    {
        this.siteCampus = siteCampus;
    }

    public String getSiteCampus() 
    {
        return siteCampus;
    }
    public void setSiteFloor(String siteFloor) 
    {
        this.siteFloor = siteFloor;
    }

    public String getSiteFloor() 
    {
        return siteFloor;
    }
    public void setSiteRegion(String siteRegion) 
    {
        this.siteRegion = siteRegion;
    }

    public String getSiteRegion() 
    {
        return siteRegion;
    }
    public void setSiteClassroom(String siteClassroom) 
    {
        this.siteClassroom = siteClassroom;
    }

    public String getSiteClassroom() 
    {
        return siteClassroom;
    }
    public void setSiteMax(Long siteMax) 
    {
        this.siteMax = siteMax;
    }

    public Long getSiteMax() 
    {
        return siteMax;
    }

    @Override
    public String toString() {
        return new ToStringBuilder(this,ToStringStyle.MULTI_LINE_STYLE)
            .append("siteId", getSiteId())
            .append("siteCampus", getSiteCampus())
            .append("siteFloor", getSiteFloor())
            .append("siteRegion", getSiteRegion())
            .append("siteClassroom", getSiteClassroom())
            .append("siteMax", getSiteMax())
            .toString();
    }
}