Boss项目：员工新增+员工编辑(2.6)

一、员工新增:

书接上回

EmployeeController:

 @PostMapping("/saveOrUpdate")
    @RequireLogin
    @ResponseBody
    public Result saveOrUpdate(@RequestBody Employee employee){


        try {
            if(StringUtils.isEmpty(employee.getId())){
                //新增
                employeeService.save(employee);

            }else {
                //编辑
                //employeeService.edit(employee);
            }
        } catch (Exception e) {
            e.printStackTrace();
            return Result.fail(e.getMessage());
        }

        return Result.success();
    }

①实现employeeService.save(employee)方法：

employeeService

↓

employeeServiceImpl：

@Override
    public void save(Employee employee) {
       employee.setAdmin(employee.getAdmin()==null?false:employee.getAdmin());
        //1.员工信息表添加
        int m = employeeMapper.insert(employee);
        if(m <= 0){
            throw new RuntimeException("添加员工失败");
        }

        //2.员工角色关系表添加 是管理员
        if(StringUtils.isEmpty(employee.getAdmin()) && employee.getAdmin()){
            return;
        }
        //不是管理员
        if(StringUtils.isEmpty(employee.getIds()) || employee.getIds().size()==0){
            return ;
        }
        List<EmployeeRole> employeeRoleList = employee.getIds().stream()
                .map(id -> new EmployeeRole(employee.getId(),id))
                .collect(Collectors.toList());
        m = employeeRoleService.saveList(employeeRoleList);
        if(m <= 0){
            throw new RuntimeException("添加员工角色信息失败");
        }

    }

如果前端没勾选admin则设为false；若前端勾选了admin则设为true；

首先添加employee表信息

再根据是否为管理员进行判断

若是管理员，则直接跳过employee_role表的添加逻辑，不再执行后续代码
若不是管理员
- 若前端没给该员工分配角色，则则直接跳过employee_role表的添加逻辑，不再执行后续代码
- 获取前端传的角色id列表，并将 List 转换为 Stream 流，遍历每个角色id，生成一个EmployeeRole对象，最后将 Stream 处理后的结果收集成 List；最后执行employee_role表的添加。
  
  .map(id -> new EmployeeRole(employee.getId(),id))核心转换：遍历每个角色id，生成一个EmployeeRole对象
  
  - employee.getId()：当前新增员工的id（刚插入员工表生成的主键）
  
  - id：遍历的角色 id
  
  例如，员工id为101，角色id为[2,5,7]
```
employeeRoleList = [
    EmployeeRole {
        employeeId: 101,  // 当前员工的ID
        roleId: 2         // 第一个角色ID
    },
    EmployeeRole {
        employeeId: 101,  // 同一个员工ID
        roleId: 5         // 第二个角色ID
    },
    EmployeeRole {
        employeeId: 101,  // 同一个员工ID
        roleId: 7         // 第三个角色ID
    }
]
```

②补充EmployeeRole：

EmployeeRole：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class EmployeeRole {
    private Long employeeId;
    private Long roleId;
}

EmployeeRoleService：

public interface EmployeeRoleService {

}

EmployeeRoleServiceImpl：

@Service
public class EmployeeRoleServiceImpl implements EmployeeRoleService {
    @Autowired
    private EmployeeRoleMapper employeeRoleMapper;
}

EmployeeRoleMapper：

public interface EmployeeRoleMapper {

}

③实现 employeeMapper.insert(employee)方法：

employeeMapper：

@Insert("insert into employee(name,password,email,age,admin,dept_id) values(#{name},#{password},#{email},#{age},#{admin},#{deptId})")
@Options(useGeneratedKeys = true, keyProperty = "id")
int insert(Employee employee);

④实现employeeRoleService.saveList(employeeRoleList)方法：

employeeRoleService：

public interface EmployeeRoleService {
    int saveList(List<EmployeeRole> employeeRoleList);

}

EmployeeRoleServiceImpl：

@Service
public class EmployeeRoleServiceImpl implements EmployeeRoleService {
    @Autowired
    private EmployeeRoleMapper employeeRoleMapper;

    @Override
    public int saveList(List<EmployeeRole> employeeRoleList) {
        return employeeRoleMapper.insertList(employeeRoleList);
    }

 
}

employeeRoleMapper：

public interface EmployeeRoleMapper {

    @InsertProvider(type = SQLProvider.class, method = "insertList")
    int insertList(List<EmployeeRole> employeeRoleList);

    class SQLProvider {
        public String insertList(List<EmployeeRole> employeeRoleList) {
            StringBuffer sql = new StringBuffer("insert into employee_role(employee_id,role_id) values");
            for(EmployeeRole employeeRole:employeeRoleList) {
                sql.append("(").append(employeeRole.getEmployeeId())
                        .append(",").append(employeeRole.getRoleId()).append("),");
            }
            sql.deleteCharAt(sql.length()-1);
            System.out.println(sql);
            return sql.toString();
        }
    }
}

二、员工编辑：

①EmployeeController：

 @GetMapping("/input")
    @RequireLogin
    public String inputGet(Long id,Map<String,Object> map){

        if(!(StringUtils.isEmpty(id))){
            //编辑  employee
            Employee employee = employeeService.findById(id);
            map.put("employee",employee);
        }


        //新增+编辑 depts  roles
        List<Department> departmentList =departmentService.findAll();
        map.put("depts",departmentList);
        //roles
        List<Role> roleList =roleService.findAll();
        map.put("roles",roleList);
        return "employee/input";
    }

EmployeeService：

public interface EmployeeService {

    Employee findById(Long id);
}

EmployeeServiceImpl：

    @Override
    public Employee findById(Long id) {
        Employee employee = employeeMapper.findById(id);
        //判断是否是admin，如果不是，查询role
        if(employee.getAdmin()){
            return employee;
        }
        //如果不是
        List<Role> roles = employeeRoleService.queryByEmployeeId(id);
        if(StringUtils.isEmpty(roles)|| roles.size()==0){
            return employee;
        }
        employee.setRoles(roles);
        return employee;
    }

②实现employeeMapper.findById(id)方法：

EmployeeMapper：

    @Select("select e.*, d.id as did,d.name as dname,d.sn as dsn " +
            "FROM employee e " +
            "left outer join department d on e.dept_id=d.id " +
            "where e.id=#{id}")

    @Results({
            @Result(property = "id", column = "id", id = true),
            @Result(property = "name", column = "name"),
            @Result(property = "password", column = "password"),
            @Result(property = "email", column = "email"),
            @Result(property = "age", column = "age"),
            @Result(property = "admin", column = "admin"),
            @Result(property = "deptId", column = "dept_id"),

            @Result(property = "dept.id", column = "did"),
            @Result(property = "dept.name", column = "dname"),
            @Result(property = "dept.sn", column = "dsn"),

    })
    Employee findById(Long id);

findById(id)方法正常来说是employee表、employee_role表与role表查询，查询出员工、部门以及角色信息。

但我们只查询出员工和部门信息，若是管理员则直接返回employee对象；若不是管理员，需查出角色信息，我们采用新创建一个employeeRoleService.queryByEmployeeId(id)方法来查出角色信息，再employee.setRoles(roles);，返回employee对象。

  //如果不是
  List<Role> roles = employeeRoleService.queryByEmployeeId(id);
  if(StringUtils.isEmpty(roles)|| roles.size()==0){
  	return employee;
        }
   employee.setRoles(roles);
   	return employee;

逻辑部分:

若不是管理员，则根据id查出员工角色信息；

若员工角色信息为空，则直接返回employee；

否则就将查出的角色信息赋值给employee，最后返回employee；

③实现employeeRoleService.queryByEmployeeId(id)方法：

EmployeeRoleService：

public interface EmployeeRoleService {

    List<Role> queryByEmployeeId(Long id);
}

EmployeeRoleServiceImpl：

@Service
public class EmployeeRoleServiceImpl implements EmployeeRoleService {
    @Autowired
    private EmployeeRoleMapper employeeRoleMapper;

    @Override
    public List<Role> queryByEmployeeId(Long id) {
        return employeeRoleMapper.queryByEmloyeeById(id);
    }
}

employeeRoleMapper：

  @Select("select r.* from employee_role er inner join role r on er.role_id=r.id where er.employee_id=#{id}")
    @Results({
            @Result(property = "id", column = "id", id = true),
            @Result(property = "name", column = "name"),
            @Result(property = "sn", column = "sn")
    })
    List<Role> queryByEmloyeeById(Long id);

未完待续。。。

posted on 2026-02-23 07:59 冬冬咚阅读(11) 评论(0) 收藏举报