员工管理、分类管理
一、新增员工
1.1需求分析和设计
1.2、代码开发
使用DTO精确的进行封装
1.2.1、Controller层
import com.sky.constant.JwtClaimsConstant;
import com.sky.dto.EmployeeDTO;
import com.sky.dto.EmployeeLoginDTO;
import com.sky.entity.Employee;
import com.sky.properties.JwtProperties;
import com.sky.result.Result;
import com.sky.service.EmployeeService;
import com.sky.utils.JwtUtil;
import com.sky.vo.EmployeeLoginVO;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.HashMap;
import java.util.Map;
/**
* 员工管理
*/
@RestController
@RequestMapping("/admin/employee")
@Slf4j
@Api(tags = "员工相关接口")
public class EmployeeController {
@Autowired
private EmployeeService employeeService;
@Autowired
private JwtProperties jwtProperties;
/**
* 登录
*
* @param employeeLoginDTO
* @return
*/
@PostMapping("/login")
@ApiOperation ( value = "员工登录")
public Result login(@RequestBody EmployeeLoginDTO employeeLoginDTO) {
log.info("员工登录：{}", employeeLoginDTO);
Employee employee = employeeService.login(employeeLoginDTO);
//登录成功后，生成jwt令牌
Map claims = new HashMap<>();
claims.put(JwtClaimsConstant.EMP_ID, employee.getId());
String token = JwtUtil.createJWT(
jwtProperties.getAdminSecretKey(),
jwtProperties.getAdminTtl(),
claims);
EmployeeLoginVO employeeLoginVO = EmployeeLoginVO.builder()
.id(employee.getId())
.userName(employee.getUsername())
.name(employee.getName())
.token(token)
.build();
return Result.success(employeeLoginVO);
}
/**
* 退出
*
* @return
*/
@ApiOperation ( "员工退出")
@PostMapping("/logout")
public Result logout() {
return Result.success();
}
/**
* 新增员工
* @param employeeDTO
* @return
*/
@PostMapping()
@ApiOperation ( "新增员工" )
public Result save(@RequestBody EmployeeDTO employeeDTO){
log.info ( "新增员工：{}",employeeDTO );
employeeService.save(employeeDTO);
return Result.success ();
}
1.2.2、Service层
/**
* 新增员工
* @param employeeDTO
*/
@Override
public void save(EmployeeDTO employeeDTO) {
Employee employee = new Employee ();
//对象属性拷贝
BeanUtils.copyProperties ( employeeDTO,employee );
//设置账号状态，默认正常状态1 表示锁定 2 用常量类软编码 不建议使用硬编码
employee.setStatus ( StatusConstant.ENABLE );
//设置密码 默认123456 用md5 算法加密 软编码
employee.setPassword ( DigestUtils.md5DigestAsHex ( PasswordConstant.DEFAULT_PASSWORD.getBytes ()) );
//设置当前记录的创建时间和修改时间
employee.setCreateTime ( LocalDateTime.now () );
employee.setUpdateTime ( LocalDateTime.now () );
//设置当前记录创建人id和修改人id
//TODO 后期须改为当前登录用户的id
employee.setCreateUser (10L);
employee.setUpdateUser ( 10L );
employeeMapper.insert(employee);
}1.2.3、Mapper层
/**
* 新增员工
* @param employee
*/
@Insert ( "insert into employee (name,username,password,phone,sex,id_number,create_time,update_time,create_user,update_user )" +
"values " +
"(#{name},#{username},#{password},#{phone},#{sex},#{id_number},#{create_time},#{update_time},#{create_user},#{update_user})")
void insert(Employee employee);1.3、功能测试
1.4、代码完善
1.4.1、处理异常
/**
* 处理SQL异常
* @param ex
* @return
*/
@ExceptionHandler
public Result exceptionHandler(SQLIntegrityConstraintViolationException ex){
//Duplicate entry 'zhangsan' for key 'employee.idx_username'
String message =ex.getMessage ();//获取错误信息
if (message.contains ( "Duplicate entry" )){
//动态取用户名
String[] split = message.split ( " " );
String username = split[2];
String msg =username+ MessageConstant.ALREADY_EXISTS; //返回用户名重复
return Result.error ( msg );
}else {
return Result.error (MessageConstant.UNKNOWN_ERROR );//返回未知错误
}
}1.4.2、新增员工时创建人id 和 修改人ID设置成了固定值
//将当前线程的ID设置为当前登录者的ID，然后传给UserService ，由UserService 获取并设置
public class BaseContext {
public static ThreadLocal threadLocal = new ThreadLocal<>();
public static void setCurrentId(Long id) {
threadLocal.set(id);
}
public static Long getCurrentId() {
return threadLocal.get();
}
public static void removeCurrentId() {
threadLocal.remove();
}
}
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
System.out.println ("当前线程的id："+Thread.currentThread ().getId ());
//判断当前拦截到的是Controller的方法还是其他资源
if (!(handler instanceof HandlerMethod)) {
//当前拦截到的不是动态方法，直接放行
return true;
}
//1、从请求头中获取令牌
String token = request.getHeader(jwtProperties.getAdminTokenName());
//2、校验令牌
try {
log.info("jwt校验:{}", token);
Claims claims = JwtUtil.parseJWT(jwtProperties.getAdminSecretKey(), token);
Long empId = Long.valueOf(claims.get(JwtClaimsConstant.EMP_ID).toString());
log.info("当前员工id：", empId);
BaseContext.setCurrentId ( empId ); //将当前线程的ID设置为当前登录者的ID，然后传给UserService ，由UserService 获取
//3、通过，放行
return true;
} catch (Exception ex) {
//4、不通过，响应401状态码
response.setStatus(401);
return false;
}
} @Override
public void save(EmployeeDTO employeeDTO) {
System.out.println ("当前线程的id："+Thread.currentThread ().getId ());
Employee employee = new Employee ();
//对象属性拷贝
BeanUtils.copyProperties ( employeeDTO,employee );
//设置账号状态，默认正常状态1 表示锁定 2 用常量类软编码 不建议使用硬编码
employee.setStatus ( StatusConstant.ENABLE );
//设置密码 默认123456 用md5 算法加密 软编码
employee.setPassword ( DigestUtils.md5DigestAsHex ( PasswordConstant.DEFAULT_PASSWORD.getBytes ()) );
//设置当前记录的创建时间和修改时间
employee.setCreateTime ( LocalDateTime.now () );
employee.setUpdateTime ( LocalDateTime.now () );
//设置当前记录创建人id和修改人id
employee.setCreateUser ( BaseContext.getCurrentId () );
employee.setUpdateUser ( BaseContext.getCurrentId () );
employeeMapper.insert(employee);
}二、员工分页查询
2.1、需求分析和设计
2.2、代码开发
2.2.1、Controller层
@GetMapping("/page")
@ApiOperation ( "员工分页查询" )
public Result page(EmployeePageQueryDTO employeePageQueryDTO){
log.info ( "员工分页查询，参数为：{}",employeePageQueryDTO );
PageResult pageResult= employeeService.pageQuery(employeePageQueryDTO);
return Result.success (pageResult);
}
2.2.2、Service层
/**
* 分页查询
* @param employeePageQueryDTO
* @return
*/
@Override
public PageResult pageQuery(EmployeePageQueryDTO employeePageQueryDTO) {
//select * from employee limit 0,10;
//开始分页查询
PageHelper.startPage ( employeePageQueryDTO.getPage (), employeePageQueryDTO.getPageSize ());
//使用分页插件 返回值的类型必须是 Page
Page page =employeeMapper.pageQuery(employeePageQueryDTO);
long total = page.getTotal ();
List records = page.getResult ();
return new PageResult (total,records);
} 2.2.3Mapper层
2.3、功能测试
2.3.1、Swagger接口文档测试
存在问题：返回的时间格式不正确
2.4、代码完善
2.4.1、在属性上加入注解
import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
import java.time.LocalDateTime;
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Employee implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
private String username;
private String name;
private String password;
private String phone;
private String sex;
private String idNumber;
private Integer status;
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime createTime;
//@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
private LocalDateTime updateTime;
private Long createUser;
private Long updateUser;
}
2.4.2、扩展消息转换器对日期统一格式化
//重写父类（WebMvcConfigurationSupport）的方法来扩展消息转换器
/**
* 扩展Spring MVC框架的消息转换器
* @param converters
*/
@Override
protected void extendMessageConverters(List> converters) {
log.info ( "扩展消息转换器..." );
//创建消息转换器类
MappingJackson2HttpMessageConverter converter = new MappingJackson2HttpMessageConverter ();
//需要为消息转换器设置一个对象转换器，对象转换器可以将Java对象序列化为json数据(将java对象转换为json数据)
converter.setObjectMapper ( new JacksonObjectMapper () );
//将自己的消息转换器加入容器中
converters.add (0, converter );//索引0，把我们自己的消息转换器排到首位，优先使用
} 三、启用禁用员工账号
3.1、需求分析和设计
3.2、代码开发
1.Controller层
@PostMapping("/status/{status}")
@ApiOperation ( "启用禁用员工账号" )
public Result startOrStop(@PathVariable Integer status,Long id){
log.info ( "启用禁用员工账号,{},{}",status,id );
employeeService.startOrStop(status,id);
return Result.success ();
}2.service层
/**
* 启用禁用员工账号
* @param status
* @param id
*/
@Override
public void startOrStop(Integer status, Long id) {
//update employee set status =? where id=?
// Employee employee = new Employee (); //使用传统的方法创建对象
// employee.setStatus ( status );
// employee.setId ( id );
// 利用@builder注解，利用构建器去创建
Employee employee = Employee.builder ()
.status ( status )
.id ( id )
.build ();
employeeMapper.update(employee);
}3.mapper层
update employee
name =#{name},
username=#{username},
password=#{password},
phone=#{phone},
sex=#{sex},
id_number=#{idNumber},
update_time=#{updateTime},
update_user=#{updateUser},
status=#{status},
where id =#{id}
四、编辑员工
4.1、需求分析与设计
4.2、代码开发
1.Controller层
/**
* 根据ID查询员工信息
* @param id
* @return
*/
@GetMapping("/{id}")
@ApiOperation ( "根据ID查询员工" )
public Result selectById(@PathVariable Long id){
log.info ( "根据ID查询员工,{}",id );
Employee employee= employeeService.selectById(id);
return Result.success (employee);
}
/**
* 修改员工信息
* @param employeeDTO
* @return
*/
@PutMapping
@ApiOperation ( "修改员工信息" )
public Result updateEmp(@RequestBody EmployeeDTO employeeDTO){
log.info ( "修改员工信息" );
employeeService.updateEmp(employeeDTO);
return Result.success ();
} 2.Service层
/**
* 根据Id查询员工
* @param id
* @return
*/
@Override
public Employee selectById(Long id) {
Employee employee= employeeMapper.selectById(id);
employee.setPassword ( "******" );
return employee;
}
/**
* 修改员工信息
* @param employeeDTO
*/
@Override
public void updateEmp(EmployeeDTO employeeDTO) {
Employee employee = new Employee ();
//对象属性拷贝
BeanUtils.copyProperties ( employeeDTO,employee );
employee.setUpdateTime ( LocalDateTime.now () );
employee.setUpdateUser ( BaseContext.getCurrentId () );
employeeMapper.update (employee);
}
3.Mapper层
update employee
name =#{name},
username=#{username},
password=#{password},
phone=#{phone},
sex=#{sex},
id_number=#{idNumber},
update_time=#{updateTime},
update_user=#{updateUser},
status=#{status},
where id =#{id}
五、分类功能
5.1、需求分析和设计
5.2分类功能代码开发
1.Controller层
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import com.sky.result.PageResult;
import com.sky.result.Result;
import com.sky.service.impl.CategoryServiceImpl;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
@RestController
@RequestMapping("/admin/category")
@Slf4j
@Api(tags = "菜品分类接口")
public class CategoryController {
@Autowired
private CategoryServiceImpl categoryService;
/**
* 新增菜品
* @param categoryDTO
* @return
*/
@PostMapping
@ApiOperation ( value = "新增菜品接口")
public Result save(@RequestBody CategoryDTO categoryDTO){
log.info ( "新增菜品,{}",categoryDTO );
categoryService.save(categoryDTO);
return Result.success ();
}
/**
* 修改员工
* @param categoryDTO
* @return
*/
@PutMapping
@ApiOperation ( value ="修改员工接口")
public Result updateCategory(@RequestBody CategoryDTO categoryDTO){
log.info ( "修改分类,{}",categoryDTO );
categoryService.updateCategory(categoryDTO);
return Result.success ();
}
/**
* 菜品分页查询
* @param categoryPageQueryDTO
* @return
*/
@GetMapping("/page")
@ApiOperation ( value ="分页查询接口")
public Result page(CategoryPageQueryDTO categoryPageQueryDTO){
log.info ( "菜品分页查询,{}",categoryPageQueryDTO );
PageResult pageResult = categoryService.pageQueryCategory(categoryPageQueryDTO);
return Result.success (pageResult);
}
/**
* 启用或禁用分类
* @param status
* @return
*/
@PostMapping("/status/{status}")
@ApiOperation ( "启用或禁用分类接口" )
public Result startOrStop(@PathVariable Integer status,Long id){
log.info ( "启用禁用分类,{},{}",status,id );
categoryService.startOrStop(status,id);
return Result.success ();
}
/**
* 根据ID查询分类信息
* @param id
* @return
*/
@GetMapping("/{id}")
@ApiOperation ( "根据ID查询分类信息接口" )
public Result selectById(@PathVariable Long id){
log.info ( "根据ID查询分类信息,{id}",id );
Category category = categoryService.selectById(id);
return Result.success (category);
}
/**
* 根据ID删除分类接口
* @param id
* @return
*/
@DeleteMapping()
@ApiOperation ( "根据ID删除分类接口" )
public Result deleteById(Long id){
log.info ( "根据ID删除分类信息,{id}",id );
categoryService.deleteById(id);
return Result.success ();
}
/**
* 根据分类查询信息接口
* @param type
* @return
*/
@GetMapping("/list")
@ApiOperation ( "根据分类查询信息接口" )
public Result> list(Integer type){
log.info ( "根据分类查询信息,{}",type );
ArrayList category=categoryService.list(type);
return Result.success (category);
}
}
2.Service层
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.sky.context.BaseContext;
import com.sky.dto.CategoryDTO;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import com.sky.mapper.CategoryMapper;
import com.sky.result.PageResult;
import com.sky.service.CategoryService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.List;
@Service
public class CategoryServiceImpl implements CategoryService {
@Autowired
private CategoryMapper categoryMapper;
/**
* 新增员工
* @param categoryDTO
*/
@Override
public void save(CategoryDTO categoryDTO) {
Category category = new Category ();
//对象属性拷贝
BeanUtils.copyProperties ( categoryDTO,category );
//添加其他属性
category.setCreateTime ( LocalDateTime.now () );
category.setUpdateTime ( LocalDateTime.now ());
category.setCreateUser ( BaseContext.getCurrentId () );
category.setUpdateUser ( BaseContext.getCurrentId () );
categoryMapper.save(category);
}
/**
* 修改员工
* @param categoryDTO
*/
@Override
public void updateCategory(CategoryDTO categoryDTO) {
Category category = new Category ();
//对象属性拷贝
BeanUtils.copyProperties ( categoryDTO,category );
//添加其他属性
category.setUpdateUser ( BaseContext.getCurrentId () );
category.setUpdateTime ( LocalDateTime.now () );
categoryMapper.update(category);
}
/**
* 菜品分页查询
* @param categoryPageQueryDTO
* @return
*/
@Override
public PageResult pageQueryCategory(CategoryPageQueryDTO categoryPageQueryDTO) {
//开始分页查询
PageHelper.startPage (categoryPageQueryDTO.getPage (),categoryPageQueryDTO.getPageSize () );
//使用分页插件返回的类型必须为Page
Page page =categoryMapper.pageQueryCategory(categoryPageQueryDTO);
long total = page.getTotal ();
List records = page.getResult ();
return new PageResult (total,records);
}
/**
* 启用禁用分类
* @param status
* @param id
*/
@Override
public void startOrStop(Integer status,Long id) {
categoryMapper.startOrStop(status,id);
}
/**
* 根据ID查询分类信息
* @param id
* @return
*/
@Override
public Category selectById(Long id) {
Category category= categoryMapper.selectById(id);
return category;
}
/**
* 根据ID删除分类
* @param id
*/
@Override
public void deleteById(Long id) {
categoryMapper.deleteById(id);
}
/**
* 根据type查询分类
* @param type
* @return
*/
@Override
public ArrayList list(Integer type) {
ArrayList category= categoryMapper.list(type);
return category;
}
}
3.Mapper层
import com.github.pagehelper.Page;
import com.sky.dto.CategoryPageQueryDTO;
import com.sky.entity.Category;
import org.apache.ibatis.annotations.*;
import java.util.ArrayList;
@Mapper
public interface CategoryMapper {
/**
* 添加菜品
* @param category
*/
@Insert ( "insert into category(id,type,name,sort,create_time,update_time,create_user,update_user )"+
"values"+
"(#{id},#{type},#{name},#{sort},#{createTime},#{updateTime},#{createUser},#{updateUser})")
void save(Category category);
/**
* 修改菜品
* @param category
*/
void update(Category category);
/**
* 分页查询
* @param categoryPageQueryDTO
* @return
*/
Page pageQueryCategory(CategoryPageQueryDTO categoryPageQueryDTO);
@Select ( "select * from category where id = #{id}")
Category selectById(Long id);
@Update ( "update category set status =#{status} where id=#{id} " )
void startOrStop(Integer status, Long id);
/**
* 根据ID删除分类
* @param id
*/
@Delete ( "delete from category where id =#{id}" )
void deleteById(Long id);
/**
* 根据type查询分类信息
* @param type
* @return
*/
@Select ( "select * from category where type=#{type}" )
ArrayList list(Integer type);
}
update category
id=#{id},
type=#{type},
name=#{name},
sort=#{sort},
status=#{status},
create_time=#{createTime},
update_time=#{updateTime},
create_user=#{createUser},
update_user=#{updateUser},
where id=#{id}