SSM_MyBatis

最新推荐文章于 2021-07-10 13:04:19 发布

weixin_41496763

最新推荐文章于 2021-07-10 13:04:19 发布

阅读量111

点赞数

分类专栏： SSM # MyBatis 文章标签： mybatis

本文链接：https://blog.csdn.net/weixin_41496763/article/details/113520670

版权

SSM 同时被 2 个专栏收录

3 篇文章 0 订阅

订阅专栏

MyBatis

1 篇文章 0 订阅

订阅专栏

一、课程模块

1、多条件课程列表查询——根据课程名称及课程状态进行多条件查询

1）表关系介绍

2）根据要求进行响应结果封装对象的编写

在domain类中添加 ResponseResult

public class ResponseResult {

    private Boolean success;
    private Integer state;
    private String message;
    private Object content;

    public ResponseResult() {
    }

    public ResponseResult(Boolean success, Integer state, String message, Object content) {
        this.success = success;
        this.state = state;
        this.message = message;
        this.content = content;
    }

    public Boolean getSuccess() {
        return success;
    }

    public void setSuccess(Boolean success) {
        this.success = success;
    }

    public Integer getState() {
        return state;
    }

    public void setState(Integer state) {
        this.state = state;
    }

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public Object getContent() {
        return content;
    }

    public void setContent(Object content) {
        this.content = content;
    }
}

3）在domian层进行CourseVO层编写，表现层

CourseVO层：课程名称和课程状态查询

public class CourseVO {

    /*
    * 课程名称
    */
    private String courseName;

    /*
     课程状态
   */
    private Integer status;

    public String getCourseName() {
        return courseName;
    }

    public void setCourseName(String courseName) {
        this.courseName = courseName;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }
}

4）dao层

/*
    多条件课程列表查询
*/
public List<Course> findCourseByCondition(CourseVO courseVO);

<?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.lagou.dao.CourseMapper">

    <!--多条件课程列表查询-->
    <select id="findCourseByCondition" parameterType="com.lagou.domain.CourseVO" resultType="com.lagou.domain.Course">
        select * from course
        <where>
            <if test="courseName !=null and courseName != ''">
                and course_name like concat('%',#{courseName},'%')
            </if>
            <if test="status !=null and status != ''">
                and status = #{status}
            </if>
            <if test="true">
                and is_del != 1
            </if>
        </where>
    </select>

5）测试

2、新增课程——添加课程、教师表信息

1）思路分析

先添加课程表信息，获取添加成功后的ID值
封装教师表（主要封装课程ID），再将记录添加表中

2）dao层

/*
    新增课程信息
*/
public void saveCourse(Course course);
/*
    新增讲师信息
*/
public void saveTeacher(Teacher teacher);

<!--新增课程信息-->
    <insert id="saveCourse" parameterType="com.lagou.domain.Course">
        INSERT INTO course(
        course_name,
        brief,
        preview_first_field,
        preview_second_field,
        course_img_url,
        course_list_img,
        sort_num,
        price,
        discounts,
        sales,
        discounts_tag,
        course_description_mark_down,
        create_time,
        update_time
        ) VALUES(#{courseName},#{brief},#{previewFirstField},#{previewSecondField},#{courseImgUrl},
        #{courseListImg},#{sortNum},#{price},#{discounts},#{sales},#{discountsTag},#{courseDescriptionMarkDown},
        #{createTime},#{updateTime});

        <!--获取添加成功记录返回的ID值
        返回类型为int order="AFTER"在SQL语句执行之后  keyProperty="id"赋值给Course实体中ID属性-->
        <selectKey resultType="int" order="AFTER" keyProperty="id">
            select LAST_INSERT_ID()
        </selectKey>

    </insert>

    <!--新增讲师信息-->
    <insert id="saveTeacher" parameterType="com.lagou.domain.Teacher">
        INSERT INTO teacher(
        course_id,
        teacher_name,
        POSITION,
        description,
        create_time,
        update_time
    ) VALUES(#{courseId},#{teacherName},#{position},#{description},#{createTime},#{updateTime});
    </insert>

3）在domian层进行CourseVO层编写，表现层对象：在表现层接收前台参数

将教师表信息也放入进去

public class CourseVO {

    //主键
    private Integer id;

    //课程名称
    private String courseName;

    //课程一句话简介
    private String brief;

    //原价
    private double price;

    //原价标签
    private String priceTag;

    //优惠价
    private double discounts;

    //优惠价标签
    private String discountsTag;

    //课程内容markdown
    private String courseDescriptionMarkDown;

    //课程描述
    private String courseDescription;

    //课程分享图片url
    private String courseImgUrl;

    //是否新品
    private int isNew;

    //广告语
    private String isNewDes;

    //最后操作者
    private int lastOperatorId;


    //是否删除
    private int isDel;

    //总时长
    private int totalDuration;

    //课程列表展示图片
    private String courseListImg;

    //课程状态，0-草稿，1-上架
    private int status;

    //课程排序
    private int sortNum;

    //课程预览第一个字段
    private String previewFirstField;

    //课程预览第二个字段
    private String previewSecondField;

    //销量
    private int sales;

    //讲师姓名
    private String teacherName;

    //讲师职位
    private String position;

    //讲师描述
    private String description;

3、根据ID回显信息

1）dao层

/*
  回显课程信息（根据ID查询对应的课程信息及关联的讲师信息）
*/
public CourseVO findCourseById(Integer id);

<!--课程信息回显   public CourseVO findCourseById(Integer id);-->
    <select id="findCourseById" parameterType="int" resultType="com.lagou.domain.CourseVO">
        SELECT
         c.*,
         t.teacher_name    teacher_name,
         t.position        POSITION,
         t.description     description
        FROM course c
         LEFT JOIN teacher t
         ON c.id = t.course_id
        WHERE c.id = #{id}
    </select>

4、修改课程——修改课程、教师表信息

1）dao层

/*
  更新课程信息
*/
public void updateCourse(Course course);
/*
   更新讲师信息
*/
public void updateTeacher(Teacher teacher);

<!--更新课程信息-->
    <update id="updateCourse" parameterType="com.lagou.domain.Course">
        UPDATE course
        <trim prefix="SET" suffixOverrides=",">
            <if test="courseName != null and courseName != ''">
                course_name = #{courseName},
            </if>

            <if test="brief != null and brief != ''">
                brief=#{brief},
            </if>

            <if test="previewFirstField != null and previewFirstField != ''">
                preview_first_field=#{previewFirstField},
            </if>

            <if test="previewSecondField != null and previewSecondField != ''">
                preview_second_field=#{previewSecondField},
            </if>

            <if test="courseImgUrl != null and courseImgUrl != ''">
                course_img_url=#{courseImgUrl},
            </if>

            <if test="courseListImg != null and courseListImg != ''">
                course_list_img=#{courseListImg},
            </if>

            <if test="sortNum != null and sortNum != ''">
                sort_num=#{sortNum},
            </if>

            <if test="price != null and price != ''">
                price=#{price},
            </if>

            <if test="discounts != null and discounts != ''">
                discounts=#{discounts},
            </if>

            <if test="sales != null and sales != '' or sales==0">
                sales=#{sales},
            </if>

            <if test="discountsTag != null and discountsTag != ''">
                discounts_tag=#{discountsTag},
            </if>

            <if test="courseDescriptionMarkDown != null and courseDescriptionMarkDown != ''">
                course_description_mark_down=#{courseDescriptionMarkDown},
            </if>

            <if test="updateTime != null">
                update_time=#{updateTime},
            </if>

        </trim>

        <where>
            <if test="id!=null and id != '' ">id=#{id}</if>
        </where>

    </update>

    <!--更新讲师信息-->
    <update id="updateTeacher" parameterType="com.lagou.domain.Teacher">
        UPDATE teacher
        <trim prefix="SET" suffixOverrides=",">
            <if test="teacherName != null and teacherName != ''">
                teacher_name = #{teacherName},
            </if>

            <if test="position != null and position != ''">
                position = #{position},
            </if>

            <if test="description != null and description != ''">
                description = #{description},
            </if>

            <if test="updateTime != null">
                update_time=#{updateTime}
            </if>
        </trim>
        <where>
            <if test="courseId != null and courseId != '' ">course_id = #{courseId}</if>
        </where>
    </update>

5、修改课程状态

1）dao层

/*
    课程状态管理
*/
public void updateCourseStatus(Course course);

<!--课程状态管理-->
    <update id="updateCourseStatus" parameterType="com.lagou.domain.Course">
        update course set status= #{status},update_time = #{updateTime} where id = #{id}
    </update>

二、章节与课时

1、根据课程ID查询章节及课时信息，将章节及课时信息连表查询

1）domian层

在CourseSection章节表中添加课时对象集合

// 课时集合
private List<CourseLesson> lessonList;

2）dao层

/*
  根据课程id查询关联的章节信息及章节信息关联的课时信息
*/
public List<CourseSection> findSectionAndLessonByCourseId(Integer courseId);

<mapper namespace="com.lagou.dao.CourseContentMapper">

    <resultMap id="SectionAndLessonResultMap" type="com.lagou.domain.CourseSection">
        <id property="id" column="id"></id>
        <result property="courseId" column="course_id"></result>
        <result property="sectionName" column="section_name"></result>
        <result property="description" column="description"></result>
        <result property="createTime" column="create_time"></result>
        <result property="updateTime" column="update_time"></result>
        <result property="isDe" column="is_de"></result>
        <result property="orderNum" column="order_num"></result>

        <collection property="lessonList" ofType="com.lagou.domain.CourseLesson">
            <id property="id" column="lessonId"></id>
            <result property="courseId" column="course_id"></result>
            <result property="sectionId" column="section_id"></result>
            <result property="theme" column="theme"></result>
            <result property="duration" column="duration"></result>
            <result property="isFree" column="is_free"></result>
            <result property="orderNum" column="order_num"></result>
            <result property="status" column="status"></result>
        </collection>

    </resultMap>


    <!--根据课程ID查询课程内容（章节-课时）-->
    <select id="findSectionAndLessonByCourseId" parameterType="int" resultMap="SectionAndLessonResultMap">
        SELECT  cs.*,
                  cl.id lessonid,
                  cl.course_id,
                  cl.section_id,
                  cl.theme,
                  cl.duration,
                  cl.create_time,
                  cl.update_time,
                  cl.is_del,
                  cl.order_num,
                  cl.status
                FROM course_section cs
                  LEFT JOIN course_lesson cl
                    ON cl.section_id = cs.id
                WHERE cs.course_id = #{id}
        ORDER BY cs.order_num
    </select>

2、根据课程ID查询回显章节对应的课程信息

1）dao层

/*
   回显章节对应的课程信息
*/
public Course findCourseByCourseId(int courseId);

<!--回显课程信息     public Course findCourseByCourseId(int courseId);-->
    <select id="findCourseByCourseId" parameterType="int" resultType="com.lagou.domain.Course">
        select id,course_name from course where id = #{courseId}
    </select>

3、新增章节信息

1）dao层

/*
    新增章节信息
 */
public void saveSection(CourseSection courseSection);

<!--保存章节-->
    <insert id="saveSection" parameterType="com.lagou.domain.CourseSection">
        INSERT INTO course_section(
            course_id,
            section_name,
            description,
            order_num,
            STATUS,
            create_time,
            update_time
        )VALUES(#{courseId},#{sectionName},#{description},#{orderNum},
        #{status},#{createTime},#{updateTime});
    </insert>

4、更改章节信息

1）dao层

/*
   更新章节信息
*/
void updateSection(CourseSection courseSection);

<!--更新章节 void updateSection(CourseSection courseSection);-->
    <update id="updateSection" parameterType="com.lagou.domain.CourseSection">
        UPDATE course_section
        <trim prefix="SET" suffixOverrides=",">
            <if test="sectionName != null and sectionName != ''">
                section_name = #{sectionName},
            </if>

            <if test="description != null and description != ''">
                description = #{description},
            </if>

            <if test="orderNum != null and orderNum != '' or orderNum == 0">
                order_num = #{orderNum},
            </if>

            <if test="updateTime != null">
                update_time=#{updateTime},
            </if>
        </trim>
        <where>
            <if test="id != null and id != '' ">id = #{id}</if>
        </where>
    </update>

5、修改章节状态

1）dao层

/*
   修改章节状态
 */
public void updateSectionStatus(CourseSection courseSection);

 <!--修改章节状态 public void updateSectionStatus(CourseSection courseSection);-->
    <update id="updateSectionStatus" parameterType="com.lagou.domain.CourseSection">
        update course_section set status = #{status},update_time = #{updateTime} where id = #{id}

    </update>

三、广告模块

1、广告查询——分页查询

1）表关系介绍

2）根据要求进行分页封装对象的编写

在domain类中添加 PromotionAdVO

public class PromotionAdVO {

    //当前页
    private Integer currentPage;

    //每页显示的条数
    private Integer pageSize;

    public Integer getCurrentPage() {
        return currentPage;
    }

    public void setCurrentPage(Integer currentPage) {
        this.currentPage = currentPage;
    }

    public Integer getPageSize() {
        return pageSize;
    }

    public void setPageSize(Integer pageSize) {
        this.pageSize = pageSize;
    }
}

3）在domain层PromotionAd类添加一对一关系

//声明一方关系：PromotionSpace
    private PromotionSpace promotionSpace;

4）dao层

/*
  分页查询广告信息
*/
public List<PromotionAd> findAllPromotionAdByPage();

<mapper namespace="com.lagou.dao.PromotionAdMapper">

    <resultMap id="ad_space" type="com.lagou.domain.PromotionAd">

        <id property="id" column="id"></id>
        <result property="name" column="name"/>
        <result property="spaceId" column="spaceId"/>
        <result property="keyword" column="keyword"/>
        <result property="htmlContent" column="htmlContent"/>
        <result property="text" column="text"/>
        <result property="link" column="link"/>
        <result property="startTime" column="startTime"/>
        <result property="endTime" column="endTime"/>
        <result property="createTime" column="createTime"/>
        <result property="updateTime" column="updateTime"/>
        <result property="status" column="status"/>
        <result property="priority" column="priority"/>
        <result property="img" column="img"/>
        <!--一对一 广告位 select:使用嵌套查询，将广告位的ID放进广告查询中
        JavaType是用来指定pojo中属性的类型 -->
        <association property="promotionSpace" select="com.lagou.dao.PromotionSpaceMapper.findPromotionSpaceById"
                     column="spaceId" javaType="com.lagou.domain.PromotionSpace">

        </association>

    </resultMap>


    <!--分页查询广告信息-->
    <select id="findAllPromotionAdByPage" resultMap="ad_space">
        select * from promotion_ad
    </select>
</mapper>

5）在applicationContext-dao.xml中

<!--2.sqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"></property>
        <property name="typeAliasesPackage" value="com.lagou.domain"/>
        <property name="plugins">
            <array>
                <bean class="com.github.pagehelper.PageHelper">
                    <property name="properties">
                        <!--支持mysql-->
                        <value>helperDialect=mysql</value>
                    </property>
                </bean>
            </array>
        </property>

2、广告动态上下线

1）dao层

/*
   广告动态上下线
*/
public void updatePromotionAdStatus(PromotionAd promotionAd);

 <!--广告动态上下线     public void updatePromotionAdStatus(PromotionAd promotionAd);-->
    <update id="updatePromotionAdStatus" parameterType="com.lagou.domain.PromotionAd">
        update promotion_ad set status = #{status},updateTime = #{updateTime} where id = #{id}
    </update>

四、用户模块

1、用户查询——条件查询、分页查询

1）表关系介绍

2）根据要求进行分页封装对象的编写

在domain类中添加 UserVo

public class UserVo {

    private Integer currentPage;
    private Integer pageSize;

    // 多条件查询：用户名（手机号）
    private String username;
    // 注册起始时间 2020/11/11 2020-08-04
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date startCreateTime;
    // 注册结束时间
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    private Date endCreateTime;

3）dao层

/*
  用户分页&多条件组合查询
*/
public List<User> findAllUserByPage(UserVo userVo);

<mapper namespace="com.lagou.dao.UserMapper">

    <!--用户分页&多条件组合查询    public List<User> findAllUserByPage(UserVo userVo);-->
    <select id="findAllUserByPage" parameterType="com.lagou.domain.UserVo" resultType="com.lagou.domain.User">
        select * from user
        <where>
            <if test="true">
                and is_del !=1
            </if>
            <if test="username !=null and username !=''">
                and name = #{username}
            </if>
            <if test="startCreateTime !=null and endCreateTime !=null">
                and create_time BETWEEN #{startCreateTime} AND #{endCreateTime}
            </if>
        </where>

    </select>

</mapper>

2、用户登录——用户查询

1）dao层

    /*
        用户登陆（根据用户名查询具体的用户信息）
     */
    public User login(User user);

<!--根据用户名查询用户  public User login(User user);-->
    <select id="login" parameterType="com.lagou.domain.User" resultType="com.lagou.domain.User">
        select * from user where phone = #{phone}
    </select>

2、用户分配角色——根据用户ID查询关联的角色信息多个角色

1）dao层

   /*
       1. 根据用户ID查询关联的角色信息 多个角色
   */
    public List<Role>  findUserRelationRoleById(Integer id);

 <!-- 1. 根据用户ID查询关联的角色信息 public List<Role>  findUserRelationRoleById(Integer id);-->
    <select id="findUserRelationRoleById" parameterType="int" resultType="com.lagou.domain.Role">
        SELECT * FROM roles r INNER JOIN user_role_relation ur ON r.id = ur.role_id WHERE ur.user_id = #{userid}
    </select>

2、用户分配角色

1）domain层，在UserVo类中添加

private List<Integer> roleIdList;

private Integer userId;

2）dao层

    /*
        根据用户ID清空中间表
     */
    public void deleteUserContextRole(Integer userId);


    /*
        分配角色
     */
    public void userContextRole(User_Role_relation user_role_relation);

<!--根据userid清空中间表关联关系     public void deleteUserContextRole(Integer userId);-->
    <delete id="deleteUserContextRole" parameterType="int" >
        delete from user_role_relation where user_id = #{userid}
    </delete>

    <!--分配角色 userContextRole-->
    <insert id="userContextRole" parameterType="com.lagou.domain.User_Role_relation">
       insert into user_role_relation values(null,#{userId},#{roleId},#{createdTime},#{updatedTime},#{createdBy},#{updatedby})
    </insert>

3、用户——动态获取菜单

1）dao层

   /*
       1. 根据用户ID查询关联的角色信息 多个角色
   */
    public List<Role>  findUserRelationRoleById(Integer id);


    /*
       2. 根据角色ID，查询角色所拥有的顶级菜单（-1）
     */
    public List<Menu> findParentMenuByRoleId(List<Integer> ids);


    /*
       3. 根据PID，查询子菜单信息
     */
    public List<Menu> findSubMenuByPid(Integer pid);


    /*
        4.获取用户拥有的资源权限信息
     */
    public List<Resource> findResourceByRoleId(List<Integer> ids);

<!-- 1. 根据用户ID查询关联的角色信息 public List<Role>  findUserRelationRoleById(Integer id);-->
    <select id="findUserRelationRoleById" parameterType="int" resultType="com.lagou.domain.Role">
        SELECT * FROM roles r INNER JOIN user_role_relation ur ON r.id = ur.role_id WHERE ur.user_id = #{userid}
    </select>


    <!--2.根据角色ID，查询角色所拥有的顶级菜单（-1）-->
    <select id="findParentMenuByRoleId" parameterType="java.util.List" resultType="com.lagou.domain.Menu">
        SELECT
        DISTINCT m.*
        FROM
        roles r INNER JOIN role_menu_relation rm ON r.id = rm.role_id
        INNER JOIN menu m ON m.id =rm.menu_id
        WHERE
        m.parent_id = -1 AND r.id IN
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>

    </select>


    <!--3. 根据PID，查询子菜单信息-->
    <select id="findSubMenuByPid" parameterType="int" resultType="com.lagou.domain.Menu">
         SELECT * FROM menu WHERE parent_id = #{pid}
    </select>


    <!--4.获取用户拥有的资源权限信息-->
    <select id="findResourceByRoleId" parameterType="java.util.List" resultType="com.lagou.domain.Resource">
        SELECT
        DISTINCT r.*
        FROM
        resource r INNER JOIN role_resource_relation rr ON r.id = rr.resource_id
        INNER JOIN roles ro ON ro.id = rr.role_id
        WHERE ro.id IN
        <foreach collection="list" item="item" open="(" separator="," close=")">
            #{item}
        </foreach>
    </select>

四、权限管理模块

1、角色查询——条件查询

1）表关系介绍

2）dao层

/*
  查询所有角色&条件进行查询
*/
public List<Role> findAllRole(Role role);

<!--查询所有角色（条件）-->
    <select id="findAllRole" parameterType="com.lagou.domain.Role" resultType="com.lagou.domain.Role">

        select * from roles
        <where>
            <if test="name !=null and name != '' ">
                and name = #{name}
            </if>
        </where>

    </select>

2、菜单查询——查询所有父子菜单信息

1）需求分析

在一张表中，查询父ID以及所有子ID，先查询父ID，然后使用嵌套查询查询所有子ID

2）domain层

在Menu类中添加，将查询到的与父级关联的子级菜单封装到subMenuList

// 声明集合：当前父级菜单所关联的子级菜单
    private List<Menu> subMenuList;

3）dao层

/*
   查询所有父子菜单信息
 */
public List<Menu> findSubMenuListByPid(int pid);


/*
  根据ID查询
*/
Menu findMenuById(Integer id);

<mapper namespace="com.lagou.dao.MenuMapper">

    <!-- 根据pid 查询所有子分类集合 -->
    <resultMap id="menuResult" type="com.lagou.domain.Menu">

        <!-- 2.封装到里面-->
        <id column="id" property="id"></id>
        <result column="href" property="href"></result>
        <result column="icon" property="icon"></result>
        <result column="name" property="name"></result>
        <result column="parent_id" property="parentId"></result>
        <result column="description" property="description"></result>
        <result column="orderNum" property="order_num"></result>
        <result column="shown" property="shown"></result>
        <result column="created_time" property="createdTime"></result>
        <result column="updated_time" property="updatedTime"></result>
        <result column="created_by" property="createdBy"></result>
        <result column="updated_by" property="updatedBy"></result>

         <!-- 3.传递ID值以及为父级菜单ID值-->
         <!-- 5.封装到subMenuList-->
        <collection property="subMenuList" ofType="com.lagou.domain.Menu"
                    select="findSubMenuListByPid" column="id">
        </collection>
    </resultMap>

    <!-- 一对多: 查询所有父子菜单信息 1.第一次执行-->
    <!-- 4.在调用查询时，根据父级菜单ID值 查询关联子菜单信息-->
    <select id="findSubMenuListByPid" parameterType="int" resultMap="menuResult">
        SELECT * FROM menu WHERE parent_id = #{id}
    </select>

3、角色查询——根据角色ID查询该角色关联的菜单信息ID

1）dao层

/*
   根据角色ID查询该角色关联的菜单信息ID [1,2,3,5]
*/
public List<Integer> findMenuByRoleId(Integer roleid);

<!-- 根据角色ID查询关联的菜单信息ID public List<Integer> findMenuByRoleId(Integer roleid);-->
    <select id="findMenuByRoleId" resultType="int" parameterType="int">
        SELECT m.id
            FROM roles r INNER JOIN role_menu_relation rm ON r.id = rm.role_id
	                     INNER JOIN menu m ON m.id = rm.menu_id WHERE r.id =#{id}
    </select>

4、角色分配——为角色分配菜单

1）domain层

public class RoleMenuVo {

    private Integer roleId;

    private List<Integer> menuIdList;

2）dao层

    /*
        根据roleid清空中间表的关联关系
     */
    public void deleteRoleContextMenu(Integer rid);


    /*
        为角色分配菜单信息
     */
    public void roleContextMenu(Role_menu_relation role_menu_relation);

<!--根据roleid删除在中间表与菜单的关联关系-->
    <delete id="deleteRoleContextMenu" parameterType="int">
        delete  from role_menu_relation where role_id = #{rid}
    </delete>

    <!--为角色分配菜单-->
    <insert id="roleContextMenu" parameterType="com.lagou.domain.Role_menu_relation">
        insert into role_menu_relation values(null,#{menuId},#{roleId},#{createdTime},#{updatedTime},#{createdBy},#{updatedby})
    </insert>

5、角色删除

1）dao层

    /*
        删除角色
     */
    public void deleteRole(Integer roleid);

<!--删除角色     public void deleteRole(Integer roleid);-->
    <delete id="deleteRole" parameterType="int">
        delete from roles where id = #{roleid}
    </delete>

6、查询所有菜单列表

1）dao层

    /*
       查询所有菜单列表
    */
    public List<Menu> findAllMenu();

 <!--查询所有菜单信息     public List<Menu> findAllMenu();-->
    <select id="findAllMenu" resultType="com.lagou.domain.Menu">
        select * from menu
    </select>

7、查询所有菜单信息——根据ID查询，进行回显菜单信息，为添加/修改做准备

1）dao层

    /*
       根据ID查询
     */
    Menu findMenuById(Integer id);

<!--根据ID查询menu    Menu findMenuById(Integer id);-->
    <select id="findMenuById" parameterType="int" resultType="com.lagou.domain.Menu">
        select * from menu where id = #{id}
    </select>

五、资源模块

1、查询资源信息——分页+多条件查询

1）domain层

添加ResourseVo类

public class ResourseVo {

    private Integer currentPage;
    private Integer pageSize;
    private String name;
    private Integer categoryId;
    private String url;

2）dao层

    /*
        资源分页&多条件查询
     */
    public List<Resource> findAllResourceByPage(ResourseVo resourseVo);

<mapper namespace="com.lagou.dao.ResourceMapper">

    <!--分页&多条件查询资源-->
    <select id="findAllResourceByPage" parameterType="com.lagou.domain.ResourseVo" resultType="com.lagou.domain.Resource">
        select * from resource
        <where>
            <if test="name != null and name != ''">
                and name like concat('%',#{name},'%')
            </if>

            <if test="url != null and url != ''">
                and url = #{url}
            </if>

            <if test="categoryId != null and categoryId != ''">
                and category_id = #{categoryId}
            </if>
        </where>
    </select>
    
</mapper>

2、查询所有资源分类

1）dao层

    /*
        查询所有资源分类
     */
    public List<ResourceCategory> findAllResourceCategory();

<mapper namespace="com.lagou.dao.ResourceCategoryMapper">

    <!--查询所有资源分类-->
    <select id="findAllResourceCategory" resultType="com.lagou.domain.ResourceCategory">
        select * from resource_category
    </select>

</mapper>

weixin_41496763

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
SSM_MyBatis

1、多条件课程列表查询——根据课程名称及课程状态进行多条件查询1）表关系介绍 2）根据要求进行响应结果封装对象的编写在domain类中添加ResponseResultpublic class ResponseResult { private Boolean success; private Integer state; private String message; private Object content; public Respon.
复制链接

扫一扫

专栏目录