Spring Security实战案例

web.xml

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <filter>
        <filter-name>characterEncodingFilter</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter>
        <filter-name>springSecurityFilterChain</filter-name>
        <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    <filter-mapping>
        <filter-name>springSecurityFilterChain</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/*.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd
       ">

    <!--加载属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>

    <!--配置数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

    <!--配置SQLSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!--数据源-->
        <property name="dataSource" ref="dataSource"/>
        <!--mybatis配置文件-->
        <property name="configLocation" value="classpath:mybatis-config.xml" />
        <!--mapper文件位置-->
        <property name="mapperLocations" value="classpath:mapper/*.xml"/>
        <!--pojo类包别名-->
        <property name="typeAliasesPackage" value="com.hgd.health.pojo"/>
        <!--分页插件pagehelper-->
        <property name="plugins">
            <list>
                <bean class="com.github.pagehelper.PageInterceptor">
                    <property name="properties">
                        <props>
                            <prop key="helperDialect"></prop>
                        </props>
                    </property>
                </bean>
            </list>
        </property>
    </bean>

    <!--配置mapper文件扫描-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.hgd.health.mapper"/>
    </bean>

    <!--配置事务管理器-->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    <!--事务注解驱动-->
    <tx:annotation-driven/>

</beans>

spring-mvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd
       ">

    <!--自动扫包-->
    <context:component-scan base-package="com.hgd.health.*"/>

    <!--跨域问题-->
    <mvc:cors>
        <mvc:mapping path="/**"
                     allowed-origins="http://localhost:1000"
                     allowed-methods="OPTIONS,GET,PUT,POST,DELETE"
                     allow-credentials="true" max-age="3600"/>
    </mvc:cors>

    <!--注解驱动-->
    <mvc:annotation-driven>
        <!--配置fastjson作为SpringMVC中json数据的转换工具-->
        <mvc:message-converters>
            <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
                <property name="supportedMediaTypes" value="application/json;charset=utf-8"/>
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <!--文件上传-->
    <bean id="multipartResolver"
          class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="104857600"/>
        <property name="maxInMemorySize" value="4096"/>
        <property name="defaultEncoding" value="UTF-8"/>
    </bean>

</beans>

spring-security.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:security="http://www.springframework.org/schema/security"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security.xsd
       ">

    <!--增加权限的支持-->
    <security:global-method-security pre-post-annotations="enabled"/>

    <!--配置需要授权访问的资源及访问角色及权限-->
    <security:http auto-config="true" use-expressions="true">

        <!--自定义登陆配置-->
        <security:form-login
            login-page="http://127.0.0.1:1000/pages/login.html"
            login-processing-url="/sec/login.do"
            authentication-success-forward-url="/user/loginSuccess.do"
            authentication-failure-forward-url="/user/loginFail.do"/>

        <!--启用自定义登陆-->
        <security:csrf disabled="true"/>

        <!--
          logout：退出登录
          logout-url：退出登录操作对应的请求路径, /logout.do为Spring Security提供的默认退出登录的请求操作
          logout-success-url：退出登录后的跳转页面
          invalidate-session: 销毁Session中的当前对象
        -->
        <security:logout
                logout-url="/sec/logout.do"
                logout-success-url="http://localhost:1000/pages/login.html"
                invalidate-session="true"
        />

    </security:http>

    <!-- 3.配置认证授权管理器（认证管理者、认证提供者、认证对象）-->
    <security:authentication-manager>
        <!--authentication-provider：认证提供者，执行具体的认证逻辑-->
        <security:authentication-provider user-service-ref="securityUserDetailsService">
            <!--使用BCrypt加密技术, 对密码加密-->
            <security:password-encoder ref="passwordEncoder"/>
        </security:authentication-provider>
    </security:authentication-manager>

    <!--配置自定义授权服务对象-->
    <bean id="securityUserDetailsService"
          class="com.hgd.health.security.SecurityUserDetailsService"/>

    <!--配置BCrypt密码加密对象-->
    <bean id="passwordEncoder" class="org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder"/>

</beans>

jdbc.properties

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/hk_health?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

log4j.properties

#log4j日志级别如下：
#A：off     最高等级，用于关闭所有日志记录。
#B：fatal   指出每个严重的错误事件将会导致应用程序的退出。
#C：error   指出虽然发生错误事件，但仍然不影响系统的继续运行。
#D：warn    表明会出现潜在的错误情形。
#E：info    一般和在粗粒度级别上，强调应用程序的运行全程。
#F：debug   一般用于细粒度级别上，对调试应用程序非常有帮助。
#G：all     最低等级，用于打开所有日志记录。
#但log4j只建议使用4个级别，优先级从高到低分别是:
#error>warn>info>debug
log4j.rootLogger=debug,systemOut,logFile
#输出到控制台
log4j.appender.systemOut=org.apache.log4j.ConsoleAppender
log4j.appender.systemOut.layout=org.apache.log4j.PatternLayout
log4j.appender.systemOut.layout.ConversionPattern=[%-5p][%-22d{yyyy/MM/dd HH:mm:ssS}][%l]%n%m%n
log4j.appender.systemOut.Target=System.out
#输出到文件
log4j.appender.logFile=org.apache.log4j.FileAppender
log4j.appender.logFile.layout=org.apache.log4j.PatternLayout
log4j.appender.logFile.layout.ConversionPattern=[%-5p][%-22d{yyyy/MM/dd HH:mm:ssS}][%l]%n%m%n
log4j.appender.logFile.File=D:/log/itcast_health_service_provider.log
log4j.appender.logFile.Encoding=UTF-8

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>
    <properties>
        <!--设置数据库方言-->
        <property name="dialect" value="mysql"/>
    </properties>
    <settings>
        <!--设置mybatis日志-->
        <setting name="logImpl" value="LOG4J"/>
    </settings>
</configuration>

SecurityUserDetailsService.java

package com.hgd.health.security;

import com.hgd.health.pojo.Permission;
import com.hgd.health.pojo.Role;
import com.hgd.health.pojo.User;
import com.hgd.health.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;

import java.util.ArrayList;
import java.util.List;

/**
 * @auther 黄国栋
 * @data 2020-07-10 12:54
 * @since
 */
public class SecurityUserDetailsService implements UserDetailsService {

    //注入加密对象
    @Autowired
    private BCryptPasswordEncoder passwordEncoder;

    @Autowired
    private UserService userService;

    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //1.根据用户标识（用户名），从数据库读取用户信息
        //User currentUser = userDb.get(username);
        User currentUser = userService.findByUsername(username);

        if (currentUser == null) {
            return null;
        }

        //2.提取用户信息的角色与权限关键词信息
        //3.把用户角色与权限关键词封装为List<GrantedAuthority>列表
        List<GrantedAuthority> authorityList = new ArrayList<>();
        //通过当前用户, 得到用户关联的每一个角色
        for (Role role : currentUser.getRoles()) {
            //获取当前角色中的角色关键字 存入到 授权集合中
            authorityList.add(new SimpleGrantedAuthority(role.getKeyword()));
            //通过当前角色,得到角色关联的每一个权限
            for (Permission permission : role.getPermissions()) {
                //获取当前权限中的权限关键字 存入到 授权集合中
                authorityList.add(new SimpleGrantedAuthority(permission.getKeyword()));
            }
        }

        //4.构建UserDetails对象（使用Security框架自动的User类封装），封装用户名、密码（必须是加密过的）及权限角色关键词列表
        String passwordByDB = currentUser.getPassword();
        //如果密码未加密, 必须用默认加密规则加密 {noop}
        //如果密码已加密,则不用使用默认规则加密
        //String passwordByAuth = "{noop}"+passwordByDB;
        //String passwordByAuth = passwordEncoder.encode(passwordByDB);

        UserDetails userDetails =
                new org.springframework.security.core.userdetails.User(currentUser.getUsername(), passwordByDB, authorityList);

        //控制台打印用户信息
        System.out.println("userDetails = " + userDetails);
        System.out.println("passwordByAuth = " + passwordByDB);
        return userDetails;
    }

}

controller

package com.hgd.health.controller;

import com.hgd.health.common.MessageConst;
import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.entity.Result;
import com.hgd.health.pojo.CheckGroup;
import com.hgd.health.service.CheckGroupService;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author likepei
 * @Date 2020/3/28 23:38
 * @Version v1.0
 * @Description 检查组业务控制器
 */
@Slf4j
@RestController
@RequestMapping("/checkgroup")
public class CheckGroupController {

    //依赖注入
    @Autowired
    private CheckGroupService checkGroupService;

    /**
     * 查询所有检查组
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_QUERY')")//权限控制
    @RequestMapping("/findAll")
    public Result findAll(){
        try {
            //调用service中的查询方法
            List<CheckGroup> checkGroupList = checkGroupService.findAll();
            //查询成功, 返回查询成功的信息
            return new Result(true, MessageConst.QUERY_CHECKGROUP_SUCCESS, checkGroupList);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息
            return new Result(false, MessageConst.QUERY_CHECKGROUP_FAIL);
        }
    }

    /**
     * 更新检查组
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkItemIds 前端页面传递过来的新增检查组所关联的检查项ID
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_EDIT')")//权限控制
    @RequestMapping("/edit")
    public Result edit(@RequestBody CheckGroup checkGroup, Integer[] checkItemIds){
        try {
            //调用service中的更新方法
            checkGroupService.edit(checkGroup, checkItemIds);
            //更新成功, 返回更新成功的信息
            return new Result(true, MessageConst.EDIT_CHECKGROUP_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            //更新失败, 返回更新失败的信息
            return new Result(false, MessageConst.EDIT_CHECKGROUP_FAIL);
        }
    }

    /**
     * 基于检查组Id 查询关联的检查项id
     * @param id 检查组Id
     * @return 多个检查项id
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_QUERY')")//权限控制
    @RequestMapping("/findCheckItemIdsByCheckGroupId")
    public Result findCheckItemIdsByCheckGroupId(Integer id){
        try {
            //调用service中的查询方法
            List<Integer> checkitemIds =  checkGroupService.findCheckItemIdsByCheckGroupId(id);
            //查询成功, 返回查询成功的信息
            return new Result(true, MessageConst.QUERY_CHECKITEM_SUCCESS, checkitemIds);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息
            return new Result(false, MessageConst.QUERY_CHECKITEM_FAIL);
        }
    }

    /**
     * 基于检查组id 查询检查组对象
     * @param id
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_QUERY')")//权限控制
    @RequestMapping("/findById")
    public Result findById(Integer id){
        try {
            //调用service中的查询方法
            CheckGroup checkGroup = checkGroupService.findById(id);
            //查询成功, 返回查询成功的信息
            return new Result(true, MessageConst.QUERY_CHECKGROUP_SUCCESS, checkGroup);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息
            return new Result(false, MessageConst.QUERY_CHECKGROUP_FAIL);
        }
    }

    /**
     * 添加检查项
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkitemIds 前端页面传递过来的新增检查组所关联的检查项ID
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_ADD')")//权限控制
    @RequestMapping("/add")
    public Result add(@RequestBody CheckGroup checkGroup, Integer[] checkitemIds){
        try {
            //调用service中的添加方法
            checkGroupService.add(checkGroup, checkitemIds);
            //添加成功, 返回添加成功的信息
            return new Result(true, MessageConst.ADD_CHECKGROUP_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            //添加失败, 返回添加失败的信息
            return new Result(false, MessageConst.ADD_CHECKGROUP_FAIL);
        }
    }

    /**
     * 分页查询
     * 1.调用service中的分页查询方法
     * 2.查询成功, 返回查询成功的信息 及 数据
     * 3.查询失败, 返回查询失败的信息 及 数据
     *
     * @param queryPageBean 前端页面发过来的数据( 当前页面, 每页条数, 查询条件)
     * @return 结果( 总记录数, 当前页要显示的10条检查组数据  )
     */
    @PreAuthorize("hasAuthority('CHECKGROUP_QUERY')")//权限控制
    @RequestMapping("/findPage")
    public PageResult findPage(@RequestBody QueryPageBean queryPageBean){
        //打印日志
        log.debug("QueryPageBean ==={}", queryPageBean);

        try {
            //调用service中的分页查询方法
            PageResult pageResult = checkGroupService.pageQuery(queryPageBean);
            //查询成功, 返回查询成功的信息 及 数据
            return pageResult;
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息 及 数据
            return new PageResult(0L, null);
        }
    }
}

package com.hgd.health.controller;

import com.hgd.health.common.MessageConst;
import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.entity.Result;
import com.hgd.health.pojo.CheckItem;
import com.hgd.health.service.CheckItemService;
import jdk.nashorn.internal.ir.annotations.Reference;
import lombok.extern.slf4j.Slf4j;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

/**
 * @Author likepei
 * @Date 2020/3/26 21:41
 * @Version v1.0
 * @Description 检查项业务控制器
 */
@RestController
@RequestMapping("/checkitem")
@Slf4j
public class CheckItemController {

    //依赖注入
    @Reference
    private CheckItemService checkItemService;

    /**
     * 查询所有的检查项
     * 1.调用service中的查询方法
     * 2.查询成功, 返回查询成功的信息
     * 3.查询失败, 返回查询失败的信息
     */
    @PreAuthorize("hasAuthority('CHECKITEM_QUERY')")//权限控制
    @RequestMapping("/findAll")
    public Result findAll(){
        try {
            //调用service中的查询方法
            List<CheckItem> list = checkItemService.findAll();
            //查询成功, 返回查询成功的信息
            return new Result(true, MessageConst.QUERY_CHECKITEM_SUCCESS, list);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息
            return new Result(false, MessageConst.QUERY_CHECKITEM_FAIL);
        }
    }

    /**
     * 编辑检查项
     * 1.调用service中的编辑方法
     * 2.编辑成功, 返回编辑成功的信息
     * 3.编辑失败, 返回编辑失败的信息
     * @param checkItem 前端页面 传递过来的编辑提交的表单数据
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKITEM_EDIT')")//权限控制
    @RequestMapping("/edit")
    public Result edit(@RequestBody CheckItem checkItem){
        log.debug("checkItem ==={}" + checkItem);

        try {
            //调用service中的编辑方法
            checkItemService.edit(checkItem);
            //编辑成功, 返回编辑成功的信息
            return new Result(true, MessageConst.EDIT_CHECKITEM_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            //编辑失败, 返回编辑失败的信息
            return new Result(false, MessageConst.EDIT_CHECKITEM_FAIL);
        }
    }

    /**
     * 根据id 查询检查项
     * 1.调用service中的查询方法
     * 2.查询成功, 返回查询成功的信息
     * 3.查询失败, 返回查询失败的信息
     *
     * @param id 页面传递过来的检查项ID
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKITEM_QUERY')")//权限控制
    @RequestMapping("/findById")
    public Result findById(Integer id){
        try {
            //调用service中的查询方法
            CheckItem checkItem = checkItemService.findById(id);
            //查询成功, 返回查询成功的信息
            return new Result(true, MessageConst.QUERY_CHECKITEM_SUCCESS, checkItem);
        } catch (Exception e) {
            e.printStackTrace();
            //查询失败, 返回查询失败的信息
            return new Result(false, MessageConst.QUERY_CHECKITEM_FAIL);
        }
    }

    /**
     * 删除检查项
     * 1.调用service中的删除方法
     * 2.删除成功, 返回删除成功的信息
     * 3.删除失败, 返回删除失败的信息
     * @param id
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKITEM_DELETE')")//权限控制
    @RequestMapping("/delete")
    public Result delete(Integer id){
        try {
            //调用service中的删除方法
            checkItemService.deleteById(id);
            //删除成功, 返回删除成功的信息
            return new Result(true, MessageConst.DELETE_CHECKITEM_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result(false, MessageConst.DELETE_CHECKITEM_FAIL);
        }
    }

    /**
     * 添加检查项
     * 1.调用service中的添加方法
     * 2.添加成功, 返回添加成功的信息
     * 3.添加失败, 返回添加失败的信息
     * @param checkItem
     * @return
     */
    @PreAuthorize("hasAuthority('CHECKITEM_ADD')")//权限控制
    @RequestMapping("/add")
    public Result add(@RequestBody CheckItem checkItem){
        try {
            //调用service中的添加方法
            checkItemService.add(checkItem);
            //添加成功, 返回添加成功的信息
            return new Result(true, MessageConst.ADD_CHECKITEM_SUCCESS);
        } catch (Exception e) {
            e.printStackTrace();
            return new Result(false, MessageConst.ADD_CHECKITEM_FAIL);
        }
    }

    /**
     * 查询分页数据
     * 1.调用Service获取分页结果数据
     * 2.成功，直接返回有内容的结果
     * 3.失败，返回初始化结果，记录为0，数据为空
     *
     * @param queryPageBean 页面传过来的数据( 当前页, 每条记录数, 查询条件)
     * @return 分页数据( 总记录数, 当前页要显示的10个检查项的集合对象)
     */
    @PreAuthorize("hasAuthority('CHECKITEM_QUERY')")//权限控制
    @RequestMapping("/findPage")
    public PageResult findPage(@RequestBody QueryPageBean queryPageBean){
        //日志打印
        log.debug("queryPageBean ===currentPage:{}===pageSize:{}====queryString:{}", queryPageBean.getCurrentPage(), queryPageBean.getPageSize(), queryPageBean.getQueryString());

        try {
            //调用Service获取分页结果数据
            PageResult pageResult = checkItemService.pageQuery(queryPageBean);
            //成功，直接返回有内容的结果
            return pageResult;
        } catch (Exception e) {
            e.printStackTrace();
            //失败，返回初始化结果，记录为0，数据为空
            return new PageResult(0L, null);
        }
    }
}

package com.hgd.health.controller;

import com.hgd.health.common.MessageConst;
import com.hgd.health.entity.Result;
import com.hgd.health.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.User;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    //依赖注入
    @Autowired
    private UserService userService;

    @RequestMapping("getUsername")
    public Result getUsername(){
        try {
            //SpringSecurity框架的上下中获取认证对象
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            //认证对象中 获取User对象
            User user = (User) authentication.getPrincipal();
            //从User对象中 获取 用户名
            String username = user.getUsername();
            //返回获取到的用户名
            return new Result(true, MessageConst.ACTION_SUCCESS, username);
        } catch (Exception e) {
            e.printStackTrace();
            //返回获取用户名失败
            return new Result(false, MessageConst.ACTION_FAIL);
        }
    }

    /**
     * 登录成功
     * @return
     */
    @RequestMapping("loginSuccess")
    public Result loginSuccess(){
        return new Result(true, MessageConst.LOGIN_SUCCESS);
    }

    /**
     * 登录失败
     * @return
     */
    @RequestMapping("loginFail")
    public Result loginFail(){
        return new Result(false, "登录失败");
    }


    @RequestMapping("/login")
    public Result login(String username, String password){
        System.out.println("==================================================================================================");
        System.out.println("oms backend====u:"+username+" ,p:"+password);
        if (userService.login(username, password)){
            System.out.println("login ok!!!");
            return new Result(true, MessageConst.ACTION_SUCCESS);
        } else {
            System.out.println("login fail");
            return new Result(false, MessageConst.ACTION_FAIL);
        }
    }
}

service

package com.hgd.health.service;

import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.pojo.CheckGroup;
import java.util.List;

/**
 * @Author
 * @Date 2020/3/28 23:41
 * @Version v1.0
 * @Description 检查组业务接口
 */
public interface CheckGroupService {
    /**
     * 分页查询
     * @param queryPageBean 前端页面发过来的数据( 当前页码, 每页条数, 查询条件)
     * @return 结果( 总记录数, 当前页要显示的10条检查组数据  )
     */
    PageResult pageQuery(QueryPageBean queryPageBean);

    /**
     * 添加检查组
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkitemIds 前端页面传递过来的新增检查组所关联的检查项ID
     */
    void add(CheckGroup checkGroup, Integer[] checkitemIds);

    /**
     * 基于检查组id 查询检查组对象
     * @param id 检查组id
     * @return 检查组对象
     */
    CheckGroup findById(Integer id);

    /**
     * 基于检查组Id 查询关联的检查项id
     * @param id 检查组Id
     * @return 多个检查项id
     */
    List<Integer> findCheckItemIdsByCheckGroupId(Integer id);

    /**
     * 更新检查组
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkItemIds 前端页面传递过来的新增检查组所关联的检查项ID
     * @return
     */
    void edit(CheckGroup checkGroup, Integer[] checkItemIds);

    /**
     * 查询所有检查组信息
     * @return
     */
    List<CheckGroup> findAll();
}

package com.hgd.health.service;

import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.pojo.CheckItem;

import java.util.List;

/**
 * @Author 
 * @Date 2020/3/26 21:47
 * @Version v1.0
 * @Description 检查项业务接口
 */
public interface CheckItemService {

    /**
     * 分页查询
     * @param queryPageBean 中有三个属性
     * 属性一 currentPage: 当前页码
     * 属性二 pageSize: 每页显示记录数
     * 属性三 queryString: 查询条件
     * @return
     */
    PageResult pageQuery(QueryPageBean queryPageBean);

    /**
     * 添加检查项
     * @param checkItem
     */
    void add(CheckItem checkItem);

    /**
     * 删除检查项
     * @param id
     */
    void deleteById(Integer id);

    /**
     * 根据id 查询检查项
     * @param id
     * @return
     */
    CheckItem findById(Integer id);

    /**
     * 编辑检查项
     * @param checkItem 需要更新的检查项对象
     */
    void edit(CheckItem checkItem);

    /**
     * 查询所有检查项
     * @return
     */
    List<CheckItem> findAll();
}

package com.hgd.health.service;


import com.hgd.health.pojo.User;

/**
 * @Author 
 * @Date 2020/3/26 2:50
 * @Version v1.0
 * @Description 用户业务接口
 */
public interface UserService {

    /**
     * 根据用户名获取用户信息
     * @param username
     * @return
     */
    User findByUsername(String username);

    /**
     * 用户登录
     * @param username 用户名
     * @param password 密码
     * @return
     */
    boolean login(String username, String password);
}

package com.hgd.health.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.mapper.CheckGroupDao;
import com.hgd.health.pojo.CheckGroup;
import com.hgd.health.service.CheckGroupService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @Author 
 * @Date 2020/3/28 23:43
 * @Version v1.0
 * @Description 检查组业务接口实现类
 */
@Transactional
@Service
public class CheckGroupServiceImpl implements CheckGroupService {

    //依赖注入
    @Autowired
    private CheckGroupDao checkGroupDao;

    /**
     * 分页查询
     * @param queryPageBean 前端页面发过来的数据( 当前页码, 每页条数, 查询条件)
     * @return 结果( 总记录数, 当前页要显示的10条检查组数据  )
     */
    @Override
    public PageResult pageQuery(QueryPageBean queryPageBean) {
        //设置分页插件初始参数
        PageHelper.startPage(queryPageBean.getCurrentPage(), queryPageBean.getPageSize());
        //通过Dao获取Page对象
        Page<CheckGroup> page = checkGroupDao.selectByCondition(queryPageBean.getQueryString());
        //通过Page对象，构建PageResult
        PageResult pageResult = new PageResult(page.getTotal(), page.getResult());

        return pageResult;
    }

    /**
     * 添加检查组
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkitemIds 前端页面传递过来的新增检查组所关联的检查项ID
     */
    @Override
    public void add(CheckGroup checkGroup, Integer[] checkitemIds) {
        //保存新增的检查组信息
        checkGroupDao.add(checkGroup);
        //保存新增检查组 与 勾选的检查项 , 保存到中间表里 t_checkgroup_checkitem
        //遍历检查项Id的数组, 得到每一个检查项id
        for (Integer checkitemId : checkitemIds) {
            //创建Map集合 用于存储本次sql语句的 新增检查组id 与 当前的检查项Id
            Map<String, Integer> map = new HashMap<>();
            map.put("checkgroup_id", checkGroup.getId());
            map.put("checkitem_id", checkitemId);

            //把新增检查组id 与 当前的检查项Id 保存到中间表
            checkGroupDao.addCheckGroupAndCheckItem(map);
        }
    }

    /**
     * 基于检查组id  查询 检查组对象
     * @param id 检查组id
     * @return
     */
    @Override
    public CheckGroup findById(Integer id) {
        //调用dao层 findById方法, 获取检查组对象
        return checkGroupDao.findById(id);
    }

    /**
     * 基于检查组Id 查询关联的检查项id
     * @param id 检查组Id
     * @return
     */
    @Override
    public List<Integer> findCheckItemIdsByCheckGroupId(Integer id) {
        //调用dao层 findCheckItemIdsByCheckGroupId, 获取检查项ID
        return checkGroupDao.findCheckItemIdsByCheckGroupId(id);
    }

    /**
     * 更新检查组
     * @param checkGroup 前端页面传递过来的新增检查组的表单数据
     * @param checkItemIds 前端页面传递过来的新增检查组所关联的检查项ID
     */
    @Override
    public void edit(CheckGroup checkGroup, Integer[] checkItemIds) {
        //更新检查组信息
        checkGroupDao.edit(checkGroup);
        //删除检查组 旧的依赖关系( 检查组与勾选的检查项的关系 [从中间表删除数据] )
        checkGroupDao.deleteCheckGroupAndCheckItem(checkGroup.getId());
        //重新 建立新的检查组的依赖关系( 检查组与勾选的检查项的关系[从中间表添加数据] )
        for (Integer checkItemId : checkItemIds) {
            //建立Map集合, 用于保存每一次sql执行时 用到的 检查组ID与 检查项ID
            Map<String, Integer> map = new HashMap<>();
            map.put("checkgroup_id", checkGroup.getId());
            map.put("checkitem_id", checkItemId);

            checkGroupDao.addCheckGroupAndCheckItem(map);
        }
    }

    /**
     * 查询所有的检查组信息
     * @return
     */
    @Override
    public List<CheckGroup> findAll() {
        //调用dao层的findAll方法
        return checkGroupDao.findAll();
    }

}

package com.hgd.health.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.hgd.health.entity.PageResult;
import com.hgd.health.entity.QueryPageBean;
import com.hgd.health.mapper.CheckItemDao;
import com.hgd.health.pojo.CheckItem;
import com.hgd.health.service.CheckItemService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @Author 
 * @Date 2020/3/26 21:53
 * @Version v1.0
 * @Description 检查项业务接口实现类
 */
@Transactional
@Service
public class CheckItemServiceImpl implements CheckItemService {

    //依赖注入
    @Autowired
    private CheckItemDao checkItemDao;

    //分页查询
    @Override
    public PageResult pageQuery(QueryPageBean queryPageBean) {

        /**
         * 使用分页插件PageHelper
         * 参数1: 起始页 1
         * 参数2: 每页数量 10
         */
        PageHelper.startPage(queryPageBean.getCurrentPage(), queryPageBean.getPageSize());
        //调用dao, 获取检查项数据
        Page<CheckItem> page = checkItemDao.selectByCondition(queryPageBean.getQueryString());
        //创建PageResult结果对象( 检查项的总记录数, 当前页显示需要的10条检查项数据 )
        return new PageResult(page.getTotal(), page.getResult());
    }

    //添加检查项
    @Override
    public void add(CheckItem checkItem) {
        //调用dao中, 添加检查项方法
        checkItemDao.add(checkItem);
    }

    /**
     * 删除检查项
     * @param id
     */
    @Override
    public void deleteById(Integer id) {
        //通过检查项ID, 去中间表中查询,  检查组是否用到了该检查项
        Long count = checkItemDao.countCheckItemsById(id);
        if (count >0){
            //说明检查组中使用了该检查项, 该检查项不能被删除
            throw new RuntimeException("检查组中使用了该检查项, 该检查项不能被删除");
        }
        //说明 当前的检查项没有被引用, 可以删除
        checkItemDao.deleteById(id);
    }

    /**
     * 根据ID 查询检查项
     * @param id 检查项ID
     * @return
     */
    @Override
    public CheckItem findById(Integer id) {
        //调用Dao层的findById的方法, 获取到检查项
        return checkItemDao.findById(id);
    }

    /**
     * 编辑检查项
     * @param checkItem 需要更新的检查项对象
     */
    @Override
    public void edit(CheckItem checkItem) {
        //调用Dao层的edit的方法, 获取到检查项
        checkItemDao.edit(checkItem);
    }

    /**
     * 查询所有检查项
     * @return
     */
    @Override
    public List<CheckItem> findAll() {
        //调用dao层的findAll方法, 获取所有的检查项
        return checkItemDao.findAll();
    }
}
package com.hgd.health.service.impl;

import com.hgd.health.mapper.PermissionDao;
import com.hgd.health.mapper.RoleDao;
import com.hgd.health.mapper.UserDao;
import com.hgd.health.pojo.Permission;
import com.hgd.health.pojo.Role;
import com.hgd.health.pojo.User;
import com.hgd.health.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Set;

/**
 * @Author 
 * @Date 2020/3/26 2:51
 * @Version v1.0
 * @Description 用户业务接口实现类
 */
@Service
public class UserServiceImpl implements UserService {

    //依赖注入
    @Autowired
    private UserDao userDao;
    @Autowired
    private RoleDao roleDao;
    @Autowired
    private PermissionDao permissionDao;

    /**
     * 基于用户名 获取User对象
     * @param username
     * @return
     */
    @Override
    public User findByUsername(String username) {
        //通过 用户名获取用户信息
        System.out.println("username = " + username);
        User user = userDao.findByUsername(username);
        System.out.println("user = " + user);
        //通过 用户名id  获取所关联的角色集合
        Set<Role> roleSet = roleDao.findByUserId(user.getId());
        user.setRoles(roleSet);
        //通过 每一个角色id  获取所关联的权限集合
        for (Role role : roleSet) {
            Set<Permission> permissionSet = permissionDao.findByRoleId(role.getId());
            role.setPermissions(permissionSet);
        }
        return user;
    }

    @Override
    public boolean login(String username, String password) {
        System.out.println("service_provide=======u:" + username + " p:" + password);
        if ("admin".equals(username) && "123".equals(password)){
            return true;
        }
        return false;
    }
}

Mapper

package com.hgd.health.mapper;

import com.github.pagehelper.Page;
import com.hgd.health.pojo.CheckGroup;
import org.apache.ibatis.annotations.Param;

import java.util.List;
import java.util.Map;

/**
 * @Author 
 * @Date 2020/3/28 23:44
 * @Version v1.0
 * @Description 检查组的持久层接口
 */
public interface CheckGroupDao {

    /**
     * 分页查询
     * @param queryString 查询条件
     * @return 检查组对象的集合数据
     */
    Page<CheckGroup> selectByCondition(@Param("queryString") String queryString);

    /**
     * 保存新增的检查组信息
     * @param checkGroup
     */
    void add(CheckGroup checkGroup);

    /**
     * 把新增检查组id 与 当前的检查项Id 保存到中间表
     * @param map
     */
    void addCheckGroupAndCheckItem(Map<String, Integer> map);

    /**
     * 基于检查组id  查询 检查组对象
     * @param id
     * @return
     */
    CheckGroup findById(@Param("id") Integer id);

    /**
     * 基于检查组Id 查询关联的检查项id
     * @param id
     * @return
     */
    List<Integer> findCheckItemIdsByCheckGroupId(@Param("id") Integer id);

    /**
     * 更新检查组信息
     * @param checkGroup
     */
    void edit(CheckGroup checkGroup);

    /**
     * 删除检查组 旧的依赖关系( 检查组与勾选的检查项的关系 [从中间表删除数据] )
     * @param id
     */
    void deleteCheckGroupAndCheckItem(@Param("id") Integer id);

    /**
     * 查询所有的检查组信息
     * @return
     */
    List<CheckGroup> findAll();

    /**
     * 基于套餐ID, 查询所关联的所有检查组信息
     * @param setmealId 套餐id
     * @return
     */
    List<CheckGroup> findCheckGroupById(@Param("setmealId") Integer setmealId);
}

package com.hgd.health.mapper;

import com.github.pagehelper.Page;
import com.hgd.health.pojo.CheckItem;
import org.apache.ibatis.annotations.Param;

import java.util.List;

/**
 * @Author 
 * @Date 2020/3/26 21:56
 * @Version v1.0
 * @Description 检查项的持久层接口
 */
public interface CheckItemDao {

    /**
     * 基于分页插件进行分页查询
     * @param queryString
     * @return
     */
    public Page<CheckItem> selectByCondition(@Param("queryString") String queryString);

    /**
     * 添加检查项
     * @param checkItem
     */
    void add(CheckItem checkItem);

    /**
     * 通过检查项ID, 去中间表中查询,  检查组是否用到了该检查项
     * @param id 检查项ID
     * @return 该检查项被引用的次数
     */
    Long countCheckItemsById(@Param("checkitemId") Integer id);

    /**
     * 删除检查项
     * @param id 检查项ID
     */
    void deleteById(@Param("id") Integer id);

    /**
     * 根据ID 查询检查项
     * @param id 检查项ID
     * @return
     */
    CheckItem findById(@Param("id") Integer id);

    /**
     * 编辑检查项
     * @param checkItem
     */
    void edit(CheckItem checkItem);

    /**
     * 查询所有的检查项
     * @return
     */
    List<CheckItem> findAll();

    /**
     * 基于检查组id, 获取对应所关联的所有检查项信息
     * @param checkgroupId 检查组id
     * @return
     */
    List<CheckItem> findCheckItemById(@Param("checkgroupId") Integer checkgroupId);
}

package com.hgd.health.mapper;

import com.hgd.health.pojo.Permission;
import org.apache.ibatis.annotations.Param;

import java.util.Set;

/**
 * @Author 
 * @Date 2020/2/19 10:57
 * @Version v1.0
 * @Description 权限的持久层接口
 */
public interface PermissionDao {
    /**
     * 基于角色id 获取所关联的权限集合
     * @param id
     * @return
     */
    Set<Permission> findByRoleId(@Param("id") Integer id);
}

package com.hgd.health.mapper;

import com.hgd.health.pojo.Role;
import org.apache.ibatis.annotations.Param;

import java.util.Set;

/**
 * @Author 
 * @Date 2020/2/19 10:48
 * @Version v1.0
 * @Description 角色持久层接口
 */
public interface RoleDao {
    /**
     * 基于用户id 查询关联的角色集合
     * @param id
     * @return
     */
    Set<Role> findByUserId(@Param("id") Integer id);
}

package com.hgd.health.mapper;

import com.hgd.health.pojo.User;
import org.apache.ibatis.annotations.Param;

/**
 * @Author 
 * @Date 2020/2/19 10:43
 * @Version v1.0
 * @Description 用户的持久层接口
 */
public interface UserDao {
    /**
     * 通过用户名 查询指定的用户信息
     * @param username
     * @return
     */
    User findByUsername(@Param("username") String username);
}

mapper.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.hgd.health.mapper.CheckGroupDao">

    <!--保存新增的检查组信息-->
    <insert id="add" parameterType="com.hgd.health.pojo.CheckGroup">
        insert into t_checkgroup
        values(null, #{code}, #{name}, #{helpCode}, #{sex}, #{remark}, #{attention})

        <selectKey resultType="integer" order="AFTER" keyProperty="id">
            select LAST_INSERT_ID();
        </selectKey>
    </insert>

    <!--把新增检查组id 与 当前的检查项Id 保存到中间表-->
    <insert id="addCheckGroupAndCheckItem">
        insert into t_checkgroup_checkitem
        values (#{checkgroup_id}, #{checkitem_id})
    </insert>

    <!--更新检查组信息-->
    <update id="edit" parameterType="com.hgd.health.pojo.CheckGroup">
        update t_checkgroup
        set code=#{code}, name=#{name}, helpCode=#{helpCode}, sex=#{sex}, remark=#{remark}, attention=#{attention}
        where id=#{id}
    </update>

    <!--删除检查组 旧的依赖关系( 检查组与勾选的检查项的关系 [从中间表删除数据] )-->
    <delete id="deleteCheckGroupAndCheckItem">
        delete from t_checkgroup_checkitem where checkgroup_id=#{id}
    </delete>

    <!--分页查询-->
    <select id="selectByCondition" resultType="com.hgd.health.pojo.CheckGroup">
        select * from t_checkgroup
        <where>
            <if test="queryString!=null and queryString.length>0">
                code like CONCAT('%',#{queryString},'%')
                or name like CONCAT('%',#{queryString},'%')
                or helpCode like CONCAT('%',#{queryString},'%')
            </if>
        </where>
    </select>

    <!--基于检查组id  查询 检查组对象-->
    <select id="findById" resultType="com.hgd.health.pojo.CheckGroup">
        select * from t_checkgroup where id=#{id}
    </select>

    <!--基于检查组Id 查询关联的检查项id-->
    <select id="findCheckItemIdsByCheckGroupId" resultType="java.lang.Integer">
        select checkitem_id from t_checkgroup_checkitem where checkgroup_id=#{id}
    </select>

    <!--查询所有的检查组信息-->
    <select id="findAll" resultType="com.hgd.health.pojo.CheckGroup">
        select * from t_checkgroup
    </select>

    <!--基于套餐ID, 查询所关联的所有检查组信息-->
    <select id="findCheckGroupById" resultType="com.hgd.health.pojo.CheckGroup">
        select * from t_checkgroup
        WHERE id in(select checkgroup_id from t_setmeal_checkgroup where setmeal_id=#{setmealId})
    </select>
</mapper>

<?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.hgd.health.mapper.CheckItemDao">

    <!--添加检查项-->
    <insert id="add" parameterType="com.hgd.health.pojo.CheckItem">
        insert into t_checkitem
        values (null, #{code}, #{name}, #{sex}, #{age}, #{price}, #{type}, #{attention}, #{remark})
    </insert>

    <!--编辑检查项-->
    <update id="edit" parameterType="com.hgd.health.pojo.CheckItem">
        update t_checkitem
        set code=#{code}, name=#{name}, sex=#{sex}, age=#{age}, price=#{price}, type=#{type}, attention=#{attention}, remark=#{remark}
        where id=#{id}
    </update>

    <!--删除检查项-->
    <delete id="deleteById">
        delete from t_checkitem where id=#{id}
    </delete>

    <!--基于分页插件进行分页查询-->
    <select id="selectByCondition" resultType="com.hgd.health.pojo.CheckItem" parameterType="String">
        select * from t_checkitem
        <if test="queryString!= null and queryString.length > 0">
            where code like CONCAT('%',#{queryString},'%') or name like CONCAT('%',#{queryString},'%')
        </if>
    </select>

    <!--通过检查项ID, 去中间表中查询,  检查组是否用到了该检查项-->
    <select id="countCheckItemsById" resultType="java.lang.Long">
        select count(*) from t_checkgroup_checkitem where checkitem_id=#{checkitemId}
    </select>

    <!--根据ID 查询检查项-->
    <select id="findById" resultType="com.hgd.health.pojo.CheckItem">
        select * from t_checkitem where id=#{id}
    </select>

    <!--查询所有的检查项-->
    <select id="findAll" resultType="com.hgd.health.pojo.CheckItem">
        select * from t_checkitem
    </select>

    <!--基于检查组id, 获取对应所关联的所有检查项信息-->
    <select id="findCheckItemById" resultType="com.hgd.health.pojo.CheckItem">
        select * from t_checkitem
        where id in (select checkitem_id from t_checkgroup_checkitem where checkgroup_id=#{checkgroupId})
    </select>
</mapper>

<?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.hgd.health.mapper.PermissionDao">

<!--基于角色id 获取所关联的权限集合-->
<select id="findByRoleId" resultType="com.hgd.health.pojo.Permission">
        select * from t_permission
        where id in ( select permission_id from t_role_permission where role_id=#{id} )
    </select>
</mapper>

<?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.hgd.health.mapper.RoleDao">

    <!--基于用户id 查询关联的角色集合-->
    <select id="findByUserId" resultType="com.hgd.health.pojo.Role">
        select * from t_role
        where id in( select role_id from t_user_role where user_id=#{id} )
    </select>

</mapper>

<?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.hgd.health.mapper.UserDao">

    <!--通过用户名 查询指定的用户信息-->
    <select id="findByUsername" resultType="com.hgd.health.pojo.User">
        select * from t_user where username=#{username}
    </select>

</mapper>