springsecurity-3 user, role, permission service layer and controller writing

Project directory structure

User service layer writing

public interface AdminService {
    // add administrator
    void add(Admin admin);
    // modify manager
    void update(Admin admin);
    // delete administrator [custom]
    void delete(Integer id);
    //Modify status
    void updateStatus(Integer id);
    // Query the administrator according to the id (query user details) [custom]
    Admin findById(Integer id);
    //Pagination query administrator
    Page<Admin> search(int page, int size);
    // Modify the administrator role [custom]
    void updateRoleToAdmin(Integer aid, Integer[] rids);
    // query administrator by name
    Admin findByName(String username);
    // Query all permissions of the administrator by name
    List<Permission> findAllPermission(String username);
}

User service layer implementation class

@DubboService
@Transactional
public class AdminServiceImpl implements AdminService{
    @Autowired
    private AdminMapper adminMapper;
    @Override
    public void add(Admin admin) {
        adminMapper.insert(admin);
    }

    @Override
    public void update(Admin admin) {
        // If an empty password is sent from the front end, the password is still the original password
        if(!StringUtils.hasText(admin.getPassword())){
            // query the original password
            String password = adminMapper.selectById(admin.getAid()).getPassword();
            admin.setPassword(password);
        }
        adminMapper. updateById(admin);
    }

    @Override
    public void delete(Integer id) {
        // remove all roles from the user
        adminMapper.deleteAdminAllRole(id);
        // delete users
        adminMapper.deleteById(id);
    }

    @Override
    public void updateStatus(Integer id) {
        Admin admin = adminMapper. selectById(id);
        admin.setStatus(!admin.isStatus());//Status inversion
        adminMapper. updateById(admin);
    }

    @Override
    public Admin findById(Integer id) {
        return adminMapper.findById(id);
    }

    @Override
    public Page<Admin> search(int page, int size) {
        return adminMapper.selectPage(new Page<>(page,size),null);
    }

    @Override
    public void updateRoleToAdmin(Integer aid, Integer[] rids) {
        // remove all roles from the user
        adminMapper.deleteAdminAllRole(aid);
        // re-add the admin role
        for (Integer rid : rids) {
            adminMapper.addRoleToAdmin(aid, rid);
        }
    }

    @Override
    public Admin findByName(String username) {
        QueryWrapper<Admin> wrapper = new QueryWrapper();
        wrapper.eq("username", username);
        Admin admin = adminMapper. selectOne(wrapper);
        return admin;
    }

    @Override
    public List<Permission> findAllPermission(String username) {
        return adminMapper. findAllPermission(username);
    }
}

User Controller

@RestController
@RequestMapping("/sys/admin")
public class AdminController {
    @DubboReference
    private AdminService adminService;
    @Autowired
    private Password Encoder encoder;
    /**
     * Add new administrator
     * @param admin administrator
     * @return
     */
    @PostMapping("/add")
    public BaseResult add(Admin admin){
        String password = admin. getPassword();
        password = encoder. encode(password);
        admin.setPassword(password);
        adminService. add(admin);
        return BaseResult.ok();
    }

    /**
     * Modify the administrator (if you set an empty password, it will still be the original password)
     * @param admin administrator
     * @return
     */
    @PutMapping("/update")
    public BaseResult update(Admin admin){
        String password = admin. getPassword();
        if (StringUtils.hasText(password)){ // Password is not empty and encrypted
            password = encoder. encode(password);
            admin.setPassword(password);
        }
        adminService. update(admin);
        return BaseResult.ok();
    }

    /**
     * Delete the administrator (with the corresponding role)
     * @param aid administrator id
     * @return
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer aid){
        adminService.delete(aid);
        return BaseResult.ok();
    }

    /**
     * Modify the status of the administrator
     * @param aid administrator id
     * @return
     */
    @PostMapping("/updateStatus")
    public BaseResult updateStatus(Integer aid){
        adminService. updateStatus(aid);
        return BaseResult.ok();
    }
    /**
     * Query the administrator by id (details)
     * @param aid administrator id
     * @return
     */
    @GetMapping("/findById")
    public BaseResult<Admin> findById(Integer aid) {
        Admin admin = adminService.findById(aid);
        return BaseResult.ok(admin);
    }

    /**
     * Paging query administrator
     * @param page current page
     * @param size number of entries per page
     * @return
     */
    //@PreAuthorize("hasAnyAuthority('/admin/search')")
    @GetMapping("/search")
    public BaseResult<Page<Admin>> search(int page, int size) {
        Page<Admin> adminPage = adminService. search(page, size);
        return BaseResult.ok(adminPage);
    }

    /**
     * Modify admin role
     * @param aid administrator id
     * @param rids role id
     * @return
     */
    @PostMapping("/updateRoleToAdmin")
    public BaseResult updateRoleToAdmin(Integer aid, Integer[] rids) {
        adminService.updateRoleToAdmin(aid,rids);
        return BaseResult.ok();
    }
    /**
     * Get the login administrator name
     *
     * @return administrator name
     */
    @GetMapping("/getUsername")
    public BaseResult<String> getUsername() {
        // 1. Get the session object
        SecurityContext context = SecurityContextHolder. getContext();
        // 2. Get the authentication object
        Authentication authentication = context. getAuthentication();
        // 3. Get login user information
        UserDetails userDetails = (UserDetails) authentication. getPrincipal();
        String username = userDetails. getUsername();
        return BaseResult.ok(username);
    }
}

Role service layer

/**
 * Role service interface
 */
public interface RoleService {
    // Add new role
    void add(Role role);
    // Modify the role
    void update(Role role);
    // remove role
    void delete(Integer id);
    // Query role according to id [custom]
    Role findById(Integer id);
    // query all roles
    List<Role> findAll();
    // pagination query role
    Page<Role> search(int page, int size);
    // Modify the permissions of the role [custom]
    void addPermissionToRole(Integer rid, Integer[] pids);
}

Role service layer implementation class

@DubboService
@Transactional
public class RoleServiceImpl implements RoleService{
    @Autowired
    private RoleMapper roleMapper;
    @Override
    public void add(Role role) {
        roleMapper.insert(role);
    }

    @Override
    public void update(Role role) {
        roleMapper. updateById(role);
    }

    @Override
    public void delete(Integer id) {
        // remove role
        roleMapper. deleteById(id);
        // Delete the relevant data of the role_permission intermediate table
        roleMapper. deleteRoleAllPermission(id);
        // Delete the relevant data of the user_role intermediate table
        roleMapper. deleteRoleAllAdmin(id);
    }

    @Override
    public Role findById(Integer id) {
        return roleMapper.findById(id);
    }

    @Override
    public List<Role> findAll() {
        return roleMapper. selectList(null);
    }

    @Override
    public Page<Role> search(int page, int size) {
        return roleMapper.selectPage(new Page(page,size),null);
    }

    @Override
    public void addPermissionToRole(Integer rid, Integer[] pids) {
        // remove all permissions from the role
        roleMapper. deleteRoleAllPermission(rid);
        // Add permissions to the role
        for (Integer pid : pids) {
            roleMapper.addPermissionToRole(rid,pid);
        }
    }
}

Character Controller

@RestController
@RequestMapping("/sys/role")
public class RoleController {
    @DubboReference
    private RoleService roleService;
    /**
     * New role added
     *
     * @param role role object
     * @return execution result
     */
    @PostMapping("/add")
    public BaseResult add( Role role) {
        roleService. add(role);
        return BaseResult.ok();
    }


    /**
     * modify role
     *
     * @param role role object
     * @return execution result
     */
    @PostMapping("/update")
    public BaseResult update(Role role) {
        roleService. update(role);
        return BaseResult.ok();
    }


    /**
     * Delete roles (including administrators and permissions of intermediate tables)
     *
     * @param rid role id
     * @return execution result
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer rid) {
        roleService.delete(rid);
        return BaseResult.ok();
    }


    /**
     * Query role by id
     *
     * @param rid
     * @return The role queried
     */
    @GetMapping("/findById")
    public BaseResult<Role> findById(Integer rid) {
        Role role = roleService.findById(rid);
        return BaseResult.ok(role);
    }

    /**
     * Query all roles
     * @return query result
     */
    @GetMapping("/findAll")
    public BaseResult<List<Role>> findAll() {
        List<Role> all = roleService. findAll();
        return BaseResult.ok(all);
    }

    /**
     * Pagination query role
     *
     * @param page page number
     * @param size number of entries per page
     * @return query result
     */
    @GetMapping("/search")
    public BaseResult<Page<Role>> search(int page, int size) {
        Page<Role> page1 = roleService. search(page, size);
        return BaseResult.ok(page1);
    }






    /**
     * Modify the permissions of the role
     *
     * @param rid role id
     * @param pids permission id
     * @return execution result
     */
    @PostMapping("/updatePermissionToRole")
    public BaseResult updatePermissionToRole(Integer rid, Integer[] pids) {
        roleService.addPermissionToRole(rid,pids);
        return BaseResult.ok();
    }
}

Authorization service layer

/**
 * Authorization service interface
 */
public interface PermissionService {
    // add permissions
    void add(Permission permission);
    // Modify permissions
    void update(Permission permission);
    // delete permissions [custom]
    void delete(Integer id);
    // Query permissions based on id
    Permission findById(Integer id);
    // query all permissions
    List<Permission> findAll();
    // Pagination query permission
    Page<Permission> search(int page, int size);
}

Permission service layer implementation class

@Transactional
@DubboService
public class PermissionServiceImpl implements PermissionService{
    @Autowired
    private PermissionMapper permissionMapper;
    @Override
    public void add(Permission permission) {
        permissionMapper.insert(permission);
    }

    @Override
    public void update(Permission permission) {
        permissionMapper. updateById(permission);
    }

    @Override
    public void delete(Integer id) {
        // delete permissions
        permissionMapper. deleteById(id);
        // Delete the relevant data in the role_permission table
        permissionMapper. deletePermissionAllRole(id);
    }

    @Override
    public Permission findById(Integer id) {
        return permissionMapper. selectById(id);
    }

    @Override
    public List<Permission> findAll() {
        return permissionMapper. selectList(null);
    }

    @Override
    public Page<Permission> search(int page, int size) {
        return permissionMapper. selectPage(new Page(page,size),null);
    }
}

Access Controller

@RestController
@RequestMapping("/sys/permission")
public class PermissionController {
    @DubboReference
    private PermissionService permissionService;

    /**
     * Add permissions
     * @param permission permission object
     * @return execution result
     */
    @PostMapping("/add")
    public BaseResult add(Permission permission){
        permissionService. add(permission);
        return BaseResult.ok();
    }


    /**
     * Modify permissions
     * @param permission permission object
     * @return execution result
     */
    @PostMapping("/update")
    public BaseResult update(Permission permission){
        permissionService. update(permission);
        return BaseResult.ok();
    }


    /**
     * Delete permission (including the role corresponding to the intermediate table)
     * @param pid permission id
     * @return execution result
     */
    @DeleteMapping("/delete")
    public BaseResult delete(Integer pid){
        permissionService.delete(pid);
        return BaseResult.ok();
    }


    /**
     * Query permissions based on id
     * @param pid permission id
     * @return query result
     */
    @GetMapping("/findById")
    public BaseResult<Permission> findById(Integer pid){
        Permission permission = permissionService.findById(pid);
        return BaseResult.ok(permission);
    }

    /**
     * Query all permissions
     * @return all permissions
     */
    @GetMapping("/findAll")
    public BaseResult<List<Permission>> findAll(){
        List<Permission> all = permissionService. findAll();
        return BaseResult.ok(all);
    }

    /**
     * Pagination query permission
     * @param page page
     * @param size number of entries per page
     * @return query result
     */
    @GetMapping("/search")
    public BaseResult<Page<Permission>> search(int page, int size){
        Page<Permission> permissionPage = permissionService. search(page, size);
        return BaseResult.ok(permissionPage);
    }


}