代码之家 › 专栏 › 技术社区 › ItFreak

Java双向角色管理

java

ItFreak · 技术社区 · 6 年前

public abstract class AbstractUser()

public class BasicUser extends AbstractUser()

public class AnotherUser extends AbstractUser()

现在我有了包含用户的团队:

public abstract class AbstractTeam() {
  protected List<AbstractUser> members;
}

public class PublicTeam extends AbstractTeam()

现在我需要管理团队,因此每个用户都应该有一个团队状态,例如成员、版主、管理员、所有者等。

所以我想做一些接口:

public Interface TeamRole

public Interface Member extends TeamRole

public Interface Moderator extends TeamRole

public abstract class AbstractUser implements TeamRole

现在我要做的是:让我们有一个控制器来处理删除用户创建的条目:

public boolean deleteEntry(User u, Entry e, requestingUser r) {

}

u.getEntries().removeIf(entry -> entry.equals(e));

以干净的方式而不“尝试”if语句中的所有角色?

3 回复 | 直到 6 年前

Kent Hawkings 6 年前

首先,装满鳗鱼的气垫船是正确的 AbstractUser 应该撰写 TeamRole

现在来谈谈眼前的问题。我不确定我是否完全理解你在问什么,但是我假设你在问如何检查一个 抽象用户 if 或 switch Enum 权限级别的集合,每个权限级别都有一个与权限级别直接相关的序号。下面是一个基本示例:

class enum PermissionLevel {
    MEMBER(0),
    MODERATOR(1)

    private final int level;

    PermissionLevel(int level) {
        this.level = level; 
    }

    public int getLevel() {
        return level;
    }
}

现在给我接口返回与该角色关联的权限级别的方法

public Interface TeamRole {
    PermissionLevel getPermissionLevel();

    ...
}

现在,在检查成员是否具有权限时,只需对 团队角色 那就是 抽象用户 有。

if (user.getTeamRole().getPermissionLevel().getLevel() > PermissionLevel.MEMBER.getLevel()) {
    // User has permission to do this action
}

Charles 6 年前

TeamRole变成了删除策略(也许重命名这个?)。可能需要更多的重构,但我认为总体思路是可行的。如果我们有更多的角色,我们可以添加更多的类并实现它们如何处理delete。

public class Entry{
}

public class User extends AbstractUser{
}

public abstract class AbstractUser {
    TeamRole role;
    List<Entry> entries;

    //self deletes are always ok
    public void deleteEntry(Entry e){
        this.getEntries().removeIf(entry -> entry.equals(e));
    }

    //delete depending on requested user role
    public void deleteEntry(User requestBy, Entry e){
            role.delete(this, e, requestBy);//mod or other poeple with ability to delete.
    }

    public List<Entry> getEntries() {
        return entries;
    }
};

public class BasicUser extends AbstractUser {
};

public class AnotherUser extends AbstractUser {
};

public abstract class AbstractTeam {
    protected List<AbstractUser> members;
}

public class PublicTeam extends AbstractTeam {
};

public interface TeamRole{
    public void delete(AbstractUser user, Entry entry, User requester);
}

public class Member implements TeamRole{
    @Override
    public void delete(AbstractUser user, Entry entry, User requester) {
        if(user==requester) {
            user.deleteEntry(entry);
        }
    }
}

public class Moderator implements TeamRole{
    @Override
    public void delete(AbstractUser user, Entry entry, User requester) {
        user.deleteEntry(entry);
    }
}

plalx 6 年前

总体设计思路如下:

public class TeamApplicationService {
    public void doSomethingSpecial(final String teamId) {
        final Team team = teamRepository.teamOfId(teamId);
        final TeamModerator moderator = team.findModerator(currentUserId);
        team.doSomethingSpecial(moderator);
    }
}


public class Team {
    final Map<String, TeamMember> teamMembers;

    public Team() {
        teamMembers = new HashMap<String, TeamMember>();
    }

    public void addMember(final TeamMember member) {
        teamMembers.put(member.userId(), member);
    }

    private <T> T findMemberOfRole(final Class<T> clazz, final String userId) {

        if (!teamMembers.containsKey(userId)) throw couldNotFindMember();

        try {   
            return (T)clazz.cast(teamMembers.get(userId));
        } catch (java.lang.ClassCastException e) {
            throw couldNotFindMember();
        }
    }

    private RuntimeException couldNotFindMember() {
        return new RuntimeException("Could not find member");
    }

    public TeamModerator findModerator(final String userId) {
        return this.<TeamModerator>findMemberOfRole(TeamModerator.class, userId);
    }

    public TeamMember findMember(final String userId) {
        return this.<TeamMember>findMemberOfRole(TeamMember.class, userId);
    }


    public void doSomethingSpecial(TeamModerator moderator) {
        //Moderator only
    }

    public void doSomethingGeneral(TeamMember member) {
        //Any member
    }
}

编辑:我不完全确定的要求,但这里有一个 more complex example 基于评论。