web.xml
characterEncodingFilter
org.springframework.web.filter.CharacterEncodingFilter
encoding
utf-8
springSecurityFilterChain
org.springframework.web.filter.DelegatingFilterProxy
characterEncodingFilter
/*
springSecurityFilterChain
/*
dispatcherServlet
org.springframework.web.servlet.DispatcherServlet
contextConfigLocation
classpath:spring/*.xml
1
dispatcherServlet
*.do
spring-dao.xml
spring-mvc.xml
spring-security.xml
jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/hk_health?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456log4j.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-8mybatis-config.xml
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列表
List 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 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 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 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 findCheckItemIdsByCheckGroupId(Integer id);
/**
* 更新检查组
* @param checkGroup 前端页面传递过来的新增检查组的表单数据
* @param checkItemIds 前端页面传递过来的新增检查组所关联的检查项ID
* @return
*/
void edit(CheckGroup checkGroup, Integer[] checkItemIds);
/**
* 查询所有检查组信息
* @return
*/
List 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 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 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 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 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 map = new HashMap<>();
map.put("checkgroup_id", checkGroup.getId());
map.put("checkitem_id", checkItemId);
checkGroupDao.addCheckGroupAndCheckItem(map);
}
}
/**
* 查询所有的检查组信息
* @return
*/
@Override
public List 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 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 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 roleSet = roleDao.findByUserId(user.getId());
user.setRoles(roleSet);
//通过 每一个角色id 获取所关联的权限集合
for (Role role : roleSet) {
Set 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 selectByCondition(@Param("queryString") String queryString);
/**
* 保存新增的检查组信息
* @param checkGroup
*/
void add(CheckGroup checkGroup);
/**
* 把新增检查组id 与 当前的检查项Id 保存到中间表
* @param map
*/
void addCheckGroupAndCheckItem(Map map);
/**
* 基于检查组id 查询 检查组对象
* @param id
* @return
*/
CheckGroup findById(@Param("id") Integer id);
/**
* 基于检查组Id 查询关联的检查项id
* @param id
* @return
*/
List findCheckItemIdsByCheckGroupId(@Param("id") Integer id);
/**
* 更新检查组信息
* @param checkGroup
*/
void edit(CheckGroup checkGroup);
/**
* 删除检查组 旧的依赖关系( 检查组与勾选的检查项的关系 [从中间表删除数据] )
* @param id
*/
void deleteCheckGroupAndCheckItem(@Param("id") Integer id);
/**
* 查询所有的检查组信息
* @return
*/
List findAll();
/**
* 基于套餐ID, 查询所关联的所有检查组信息
* @param setmealId 套餐id
* @return
*/
List 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 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 findAll();
/**
* 基于检查组id, 获取对应所关联的所有检查项信息
* @param checkgroupId 检查组id
* @return
*/
List 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 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 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
insert into t_checkgroup
values(null, #{code}, #{name}, #{helpCode}, #{sex}, #{remark}, #{attention})
select LAST_INSERT_ID();
insert into t_checkgroup_checkitem
values (#{checkgroup_id}, #{checkitem_id})
update t_checkgroup
set code=#{code}, name=#{name}, helpCode=#{helpCode}, sex=#{sex}, remark=#{remark}, attention=#{attention}
where id=#{id}
delete from t_checkgroup_checkitem where checkgroup_id=#{id}
select * from t_checkgroup
code like CONCAT('%',#{queryString},'%')
or name like CONCAT('%',#{queryString},'%')
or helpCode like CONCAT('%',#{queryString},'%')
select * from t_checkgroup where id=#{id}
select checkitem_id from t_checkgroup_checkitem where checkgroup_id=#{id}
select * from t_checkgroup
select * from t_checkgroup
WHERE id in(select checkgroup_id from t_setmeal_checkgroup where setmeal_id=#{setmealId})
insert into t_checkitem
values (null, #{code}, #{name}, #{sex}, #{age}, #{price}, #{type}, #{attention}, #{remark})
update t_checkitem
set code=#{code}, name=#{name}, sex=#{sex}, age=#{age}, price=#{price}, type=#{type}, attention=#{attention}, remark=#{remark}
where id=#{id}
delete from t_checkitem where id=#{id}
select * from t_checkitem
where code like CONCAT('%',#{queryString},'%') or name like CONCAT('%',#{queryString},'%')
select count(*) from t_checkgroup_checkitem where checkitem_id=#{checkitemId}
select * from t_checkitem where id=#{id}
select * from t_checkitem
select * from t_checkitem
where id in (select checkitem_id from t_checkgroup_checkitem where checkgroup_id=#{checkgroupId})
select * from t_permission
where id in ( select permission_id from t_role_permission where role_id=#{id} )
select * from t_role
where id in( select role_id from t_user_role where user_id=#{id} )
select * from t_user where username=#{username}
