Java CharacterRule类代码示例

import org.passay.CharacterRule; //导入依赖的package包/类
public static List<CharacterRule> getCharacterRules(StringGenerationParameters parameters) {
  List<CharacterRule> characterRules = new ArrayList<>();

  if (parameters.isIncludeSpecial()) {
    characterRules.add(new CharacterRule(CredHubCharacterData.Special));
  }

  if (!parameters.isExcludeNumber()) {
    characterRules.add(new CharacterRule(EnglishCharacterData.Digit));
  }

  if (!parameters.isExcludeUpper()) {
    characterRules.add(new CharacterRule(EnglishCharacterData.UpperCase));
  }

  if (!parameters.isExcludeLower()) {
    characterRules.add(new CharacterRule(EnglishCharacterData.LowerCase));
  }

  return characterRules;
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
public void generatePassword() {
    char[] special = new char[]{'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*',
         '+', '-', '.', '/', ':', '<', '=', '>', '?', '@', '[', '\\', ']',
         '^', '_', '`', '{', '|', '}', '~'};
    List<CharacterRule> rules = Arrays.asList(
            // at least one upper-case character
            new CharacterRule(EnglishCharacterData.UpperCase, 1),
            // at least one lower-case character
            new CharacterRule(EnglishCharacterData.LowerCase, 1),
            // at least one digit character
            new CharacterRule(EnglishCharacterData.Digit, 1),
            new CharacterRule(new CharacterData() {
                @Override
                public String getErrorCode() {
                    return "INSUFFICIENT_SPECIAL";
                }

                @Override
                public String getCharacters() {
                    return new String(special);
                }
            }, 1));

    PasswordGenerator generator = new PasswordGenerator();
    // Generated password is 16 characters long, which complies with policy
    String password = generator.generatePassword(16, rules);
    this.password = password.toCharArray();
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
public void generateEncryptionPassword() {
    char[] special = new char[]{'!', '"', '#', '$', '%', '&', '\'', '(', ')', '*',
         '+', ',', '-', '.', '/', ':', '<', '=', '>', '?', '@', '[', '\\', ']',
         '^', '_', '`', '{', '|', '}', '~'};
    List<CharacterRule> rules = Arrays.asList(
            // at least one upper-case character
            new CharacterRule(EnglishCharacterData.UpperCase, 1),
            // at least one lower-case character
            new CharacterRule(EnglishCharacterData.LowerCase, 1),
            // at least one digit character
            new CharacterRule(EnglishCharacterData.Digit, 1),
            new CharacterRule(new CharacterData() {
                @Override
                public String getErrorCode() {
                    return "INSUFFICIENT_SPECIAL";
                }

                @Override
                public String getCharacters() {
                    return new String(special);
                }
            }, 1));

    PasswordGenerator generator = new PasswordGenerator();
    // Generated password is 16 characters long, which complies with policy
    String password = generator.generatePassword(16, rules);
    this.encryptionPassword = password.toCharArray();
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_canCreateCharacterRulesWithoutUppercase() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setExcludeUpper(true);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(2));
  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.LowerCase),
      usesCharacters(EnglishCharacterData.Digit)
  ));
  assertThat(characterRules, not(containsInAnyOrder(
      usesCharacters(EnglishCharacterData.UpperCase),
      usesCharacters(CredHubCharacterData.Special),
      usesCharacters(CredHubCharacterData.Hex)
  )));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_canCreateCharacterRulesWithoutLowercase() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setExcludeLower(true);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(2));
  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.UpperCase),
      usesCharacters(EnglishCharacterData.Digit)
  ));
  assertThat(characterRules, not(containsInAnyOrder(
      usesCharacters(EnglishCharacterData.LowerCase),
      usesCharacters(CredHubCharacterData.Special),
      usesCharacters(CredHubCharacterData.Hex)
  )));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_canCreateCharacterRulesWithoutSpecialCharacters() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setIncludeSpecial(false);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(3));
  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.UpperCase),
      usesCharacters(EnglishCharacterData.LowerCase),
      usesCharacters(EnglishCharacterData.Digit)
  ));
  assertThat(characterRules, not(hasItem(usesCharacters(CredHubCharacterData.Special))));
  assertThat(characterRules, not(hasItem(usesCharacters(CredHubCharacterData.Hex))));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_canCreateCharacterRulesWithoutNumbers() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setExcludeNumber(true);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(2));
  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.UpperCase),
      usesCharacters(EnglishCharacterData.LowerCase)
  ));
  assertThat(characterRules, not(containsInAnyOrder(
      usesCharacters(EnglishCharacterData.Digit),
      usesCharacters(CredHubCharacterData.Special)
  )));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
private Matcher<CharacterRule> usesCharacters(CharacterData characterData) {
  return new BaseMatcher<CharacterRule>() {

    @Override
    public boolean matches(final Object item) {
      final CharacterRule rule = (CharacterRule) item;
      return rule.getValidCharacters().equals(characterData.getCharacters());
    }

    @Override
    public void describeTo(final Description description) {
      description.appendText("getValidCharacters() should equal")
          .appendValue(characterData.getCharacters());
    }
  };
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
public StringCredentialValue generateCredential(StringGenerationParameters parameters) {
  int passwordLength = normalizedLength(parameters.getLength());

  List<CharacterRule> characterRules = CharacterRuleProvider.getCharacterRules(parameters);

  return new StringCredentialValue(
      passwordGenerator.generatePassword(passwordLength, characterRules));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_createdCharacterRulesFromDefaultParameters() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);

  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.Digit),
      usesCharacters(EnglishCharacterData.LowerCase),
      usesCharacters(EnglishCharacterData.UpperCase)
  ));
  assertThat(characterRules, not(hasItem(usesCharacters(CredHubCharacterData.Hex))));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_canCreateCharacterRulesWithAllIncluded() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setIncludeSpecial(true);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(4));
  assertThat(characterRules, containsInAnyOrder(
      usesCharacters(EnglishCharacterData.UpperCase),
      usesCharacters(EnglishCharacterData.LowerCase),
      usesCharacters(EnglishCharacterData.Digit),
      usesCharacters(CredHubCharacterData.Special)
  ));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
@Test
public void getCharacterRules_returnsAnEmptyListWhenAllAreExcluded() {
  StringGenerationParameters generationParameters = new StringGenerationParameters();
  generationParameters.setIncludeSpecial(false);
  generationParameters.setExcludeNumber(true);
  generationParameters.setExcludeUpper(true);
  generationParameters.setExcludeLower(true);

  List<CharacterRule> characterRules = CharacterRuleProvider
      .getCharacterRules(generationParameters);
  assertThat(characterRules, iterableWithSize(0));
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
private String generatePassword() {
  PasswordGenerator passwordGenerator = new PasswordGenerator();

  List<CharacterRule> rules = Arrays.asList(

      // at least one upper-case character
      new CharacterRule(EnglishCharacterData.UpperCase, 1),

      // at least one lower-case character
      new CharacterRule(EnglishCharacterData.LowerCase, 1),

      // at least one digit character
      new CharacterRule(EnglishCharacterData.Digit, 1),

      // at least one symbol (special character)
      new CharacterRule(SpecialCharacterData.INSTANCE, 1));

  return passwordGenerator.generatePassword(8, rules);
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
public SecurityPasswordRulesBuilder mandatoryDigits(int min) {
	rules.add(new CharacterRule(EnglishCharacterData.Digit, min));
	return this;
}
 

import org.passay.CharacterRule; //导入依赖的package包/类
public SecurityPasswordRulesBuilder mandatoryNonAlphanumericCharacters() {
	rules.add(new CharacterRule(EnglishCharacterData.Special));
	return this;
}