ऑब्जेक्ट्स की सूची में तारों की सूची को कैसे परिवर्तित करें?

Question

मेरे पास डेटाबेस में भूमिकाओं की एक सूची है। वे

application.Role1.read 
application.Role1.write 
application.Role2.read 
application.Role3.read 

इसलिए प्रत्येक भूमिका में पढ़ने/लिखने की अनुमति के आधार पर एक प्रविष्टि है। मैं भूमिकाओं को एक पीओजेओ में परिवर्तित करना चाहता हूं जिसे मैं यूआई में जेएसओएन के रूप में भेज सकता हूं। प्रत्येक POJO में भूमिका का नाम होगा, और पढ़ने या लिखने की अनुमति के लिए एक बूलियन होगा।

import com.fasterxml.jackson.annotation.JsonInclude; 

@JsonInclude(JsonInclude.Include.NON_NULL) 
public class RolePermission { 
    private String roleName; 
    private boolean readAllowed; 
    private boolean writeAllowed; 

    public String getRoleName() { 
     return roleName; 
    } 

    public RolePermission setRoleName(String roleName) { 
     this.roleName = roleName; 
     return this; 
    } 

    public boolean isReadAllowed() { 
     return readAllowed; 
    } 

    public RolePermission setReadAllowed(boolean readAllowed) { 
     this.readAllowed = readAllowed; 
     return this; 
    } 

    public boolean isWriteAllowed() { 
     return writeAllowed; 
    } 

    public RolePermission setWriteAllowed(boolean writeAllowed) { 
     this.writeAllowed = writeAllowed; 
     return this; 
    } 
} 

मैं बहुत तरह परिवर्तन कर रहा हूँ:

public static final String ROLE_PREFIX = "application."; 
public static final String ROLE_READ_PERMISSION = "read"; 
public static final String ROLE_WRITE_PERMISSION = "write"; 

@Override 
public List<RolePermission> getRoles(Backend backend) { 
    List<String> allRoles = backend.getRoles() 
      .stream() 
      .map(s -> s.replace(ROLE_PREFIX, "")) 
      .sorted() 
      .collect(Collectors.toList()); 
    Map<String, RolePermission> roleMap = new HashMap<>(); 
    for (String role : allRoles) { 
     String[] tokens = role.split("."); 
     String roleName = tokens[0]; 
     String permission = tokens[1]; 
     if (!roleMap.containsKey(roleName)) 
      roleMap.put(roleName, new RolePermission().setRoleName(roleName)); 
     RolePermission permission = roleMap.get(roleName); 
     if (ROLE_READ_PERMISSION.equals(permission)) 
      permission.setReadAllowed(true); 
     if (ROLE_WRITE_PERMISSION.equals(permission)) 
      permission.setWriteAllowed(true); 
    } 
    return new LinkedList<>(roleMap.values()); 
} 

वहाँ जावा 8 धाराओं का इस्तेमाल करके ऊपर foreach पाश करने के लिए एक रास्ता है

यहाँ RolePermission वर्ग है?

यह एक नकली बैकएंड उदाहरण है कि बस की भूमिका निभाने की सूची लौटाता है:

public class Backend { 
    public List<String> getRoles() { 
     return Arrays.asList(
      "application.Role1.read", 
      "application.Role1.write", 
      "application.Role2.read", 
      "application.Role3.read" 
     ); 
    } 
} 

Answer 1

आप एक साथ एक ही roleName के लिए विभिन्न अनुमतियों शामिल होने के लिए groupingBy उपयोग कर सकते हैं।

public static final String ROLE_PREFIX = "application."; 
public static final String ROLE_READ_PERMISSION = "read"; 
public static final String ROLE_WRITE_PERMISSION = "write"; 

@Override 
public List<RolePermission> getRoles(Backend backend) { 
    Map<String, List<String[]>> allRoles = backend.getRoles() 
      .stream() 
      .map(s -> s.replace(ROLE_PREFIX, "")) // something like "Role1.read" 
      .map(s -> s.split("\\.")) // something like ["Role1", "read"] 
      .collect(Collectors.groupingBy(split -> split[0])); 
    return allRoles.values() 
        .stream() 
        .map(this::buildPermission) 
        .collect(Collectors.toList()); 
} 

private RolePermission buildPermission(List<String[]> roleEntries) { 
    RolePermission permission = new RolePermission().setRoleName(roleEntries.get(0)[0]); 
    roleEntries.stream() 
       .forEach(entry -> { 
        if (ROLE_READ_PERMISSION.equals(entry[1])) 
         permission.setReadAllowed(true); 
        if (ROLE_WRITE_PERMISSION.equals(entry[1])) 
         permission.setWriteAllowed(true); 
       }); 
    return permission; 
} 

मैं भी लगता है कि आपके String.split मूल पोस्ट में एक गलत regex उपयोग कर रहा था, क्योंकि . एक special regex character है। मैंने इसका परीक्षण किया है और यह सही तरीके से काम करता है।

आउटपुट: तो आप इस्तेमाल कर सकते हैं कि RolePermission (या जो भी वस्तु आप चाहते हैं) करने के लिए स्ट्रिंग मैप करने के लिए और फिर एक सूची में परिणामों को एकत्र

[RolePermission(roleName=Role3, readAllowed=true, writeAllowed=false), 
RolePermission(roleName=Role2, readAllowed=true, writeAllowed=false), 
RolePermission(roleName=Role1, readAllowed=true, writeAllowed=true)] 

Answer 2

जावा धारा मानचित्र समारोह है। क्या यह आपके लिए कुछ काम करेगा? ऐसा लगता है कि आप कम या ज्यादा पहले से ही RolePermission रूपांतरण के लिए स्ट्रिंग किया

final List<RolePermission> roles = getRoles().stream().map(roleString -> { <your conversion code> }).collect(Collectors.toList()); 

Answer 3

आपका for पाश अपने मौजूदा धारा में map की दूसरी कॉल और toMap कलेक्टर के साथ बदला जा सकता है:

public List<RolePermission> getRoles(Backend backend) 
{ 
    Map<String, RolePermission> allRoles = backend.getRoles() 
      .stream() 
      .map(s -> s.replace(ROLE_PREFIX, "")) 
      .sorted() 
      .map(this::mapStringToRolePermission) 
      .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, RolePermission::merge)); 
    return new ArrayList<>(allRoles.values()); 
} 

जहां mapStringToRolePermission :

private static Map.Entry<String, RolePermission> mapStringToRolePermission(String role) 
{ 
    String roleName = role.substring(0, role.indexOf('.')); 
    RolePermission rolePermission = new RolePermission(); 
    rolePermission.setRoleName(roleName); 
    rolePermission.setReadAllowed(role.endsWith(ROLE_READ_PERMISSION)); 
    rolePermission.setWriteAllowed(role.endsWith(ROLE_WRITE_PERMISSION)); 
    return new AbstractMap.SimpleEntry<>(roleName, rolePermission); 
} 

और एक अतिरिक्त विधि merge के लिए आर RolePermission:

public RolePermission merge(RolePermission another) 
{ 
    if (another.isReadAllowed()) 
     setReadAllowed(true); 
    if (another.isWriteAllowed()) 
     setWriteAllowed(true); 
    return this; 
}