Java Group.isMember方法代碼示例

import java.security.acl.Group; //導入方法依賴的package包/類
/**
 * Process the group with the roles that are mapped in the 
 * properies file
 * @param group Group that needs to be processed
 * @param props Properties file
 */
private void processRoles(Group group,Properties props) //throws Exception
{
   Enumeration<?> enumer = props.propertyNames();
   while(enumer.hasMoreElements())
   {
      String roleKey = (String)enumer.nextElement();
      String comma_separated_roles = props.getProperty(roleKey);
      try {
          Principal pIdentity = createIdentity(roleKey);
          if (group != null)
          {
              if(group.isMember(pIdentity))
                  Util.parseGroupMembers(group,comma_separated_roles,this);
              if(REPLACE_ROLE)
                  group.removeMember(pIdentity);
          }
      }
      catch(Exception e) {
          PicketBoxLogger.LOGGER.debugFailureToCreatePrincipal(roleKey, e);
      }
   }
}
 

import java.security.acl.Group; //導入方法依賴的package包/類
@Override
protected void authorize(LoginContext context) throws LoginException {
    HashSet<String> required = new HashSet<>(requiredRoles);
    Set<Group> groups = context.getSubject().getPrincipals(Group.class);
    if (groups != null) {
        for (Group group : groups) {
            if ("Roles".equals(group.getName())) {
                for (String role : requiredRoles) {
                    if (group.isMember(new SimplePrincipal(role))) {
                        required.remove(role);
                    }
                }
            }
        }
    }
    if (!required.isEmpty())
        throw new LoginException("User does not have required roles: " + required);
}
 

import java.security.acl.Group; //導入方法依賴的package包/類
private boolean isMemberRecurse(Principal principal, Vector<Principal> vector)
{
    for(Enumeration<Principal> enumeration = members(); enumeration.hasMoreElements();)
    {
        boolean flag = false;
        Principal principal1 = (Principal)enumeration.nextElement();
        if(principal1.equals(principal))
            return true;
        if(principal1 instanceof SecurityGroup)
        {
           SecurityGroup groupimpl = (SecurityGroup)principal1;
            vector.addElement(this);
            if(!vector.contains(groupimpl))
                flag = groupimpl.isMemberRecurse(principal, vector);
        } 
        else
        if(principal1 instanceof Group)
        {
            Group group1 = (Group)principal1;
            if(!vector.contains(group1))
                flag = group1.isMember(principal);
        }

        if(flag)
            return flag;
    }

    return false;
}
 

import java.security.acl.Group; //導入方法依賴的package包/類
public boolean hasRole(String role) {
	tryLogin();

	for (Group sg : getSubject().getPrincipals(Group.class)) {
		if (ROLES_GROUP.equals(sg.getName())) {
			return sg.isMember(new Role(role));
		}
	}
	return false;
}
 

import java.security.acl.Group; //導入方法依賴的package包/類
/**
 * Tests whether the passed subject has sufficient roles.
 *
 * @param subject
 *          the subject to test.
 * @param securable
 *          the securable to test.
 * @return true if the subject has sufficient privilege.
 */
public static boolean isSubjectGranted(Subject subject, ISecurable securable) {
  if (securable == null) {
    return true;
  }
  Collection<String> grantedRoles = securable.getGrantedRoles();
  if (grantedRoles == null) {
    return true;
  }
  if (subject == null) {
    return false;
  }

  grantedRoles = new HashSet<>(grantedRoles);
  Collection<String> ungrantedRoles = new HashSet<>();
  for (String role : new HashSet<>(grantedRoles)) {
    if (role.startsWith("!")) {
      grantedRoles.remove(role);
      ungrantedRoles.add(role.substring(1));
    }
  }

  Group subjectRoles = getRolesGroup(subject);
  if (subjectRoles != null) {
    boolean granted = false;
    if (!grantedRoles.isEmpty()) {
      for (String grantedRole : grantedRoles) {
        if (subjectRoles.isMember(new SimplePrincipal(grantedRole))) {
          granted = true;
          break;
        }
      }
    }
    if (!granted && !ungrantedRoles.isEmpty()) {
      granted = true;
      for (String ungrantedRole : ungrantedRoles) {
        if (subjectRoles.isMember(new SimplePrincipal(ungrantedRole))) {
          granted = false;
          break;
        }
      }
    }
    return granted;
  }
  return false;
}