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>