TOC

Guide pour le Printemps LDAP de données

Guide de printemps des données LDAP

1. introduction

Dans cet article,we’ll focus on Spring Data LDAP integration and configuration. Pour une introduction étape par étape à Spring LDAP, jetez un coup d'œil àthis article.

Vous trouverez également un aperçu du guide Spring Data JPAhere.

2. Maven Dépendance

Commençons par ajouter les dépendances Maven requises: 


    org.springframework.data
    spring-data-ldap
    1.0.6.RELEASE

Les dernières versions peuvent être trouvées ici pourspring-data-ldap.

3. Entrée de domaine

Le projet Spring LDAP offre la possibilité de mapper des entrées LDAP sur des objets Java à l'aide deObject-Directory Mapping (ODM).

Définissons l’entité qui sera utilisée pour mapper les répertoires LDAP qui ont déjà été configurés dans lesSpring LDAP article. 

@Entry(
  base = "ou=users",
  objectClasses = { "person", "inetOrgPerson", "top" })
public class User {
    @Id
    private Name id;

    private @Attribute(name = "cn") String username;
    private @Attribute(name = "sn") String password;

    // standard getters/setters
}

@Entry est similaire à@Entity (de JPA / ORM) qui est utilisé pour spécifier quelle entité correspond à la racine de répertoire des entrées LDAP.

Une classeEntry doit avoir une annotation@Id déclarée sur un champ de type javax.naming.Name qui représente l'entitéDN. L'annotation@Attribute est utilisée pour mapper les champs de classe d'objets aux champs d'entité.

4. Référentiel de données Spring

Spring Data Repository est une abstraction qui fournit une implémentation prête à l'emploi de base prête à l'emploi des couches d'accès aux données pour divers magasins de persistance.

Spring Framework internally provides the implementation of CRUD operations pour une classe donnée dans le référentiel de données. Nous pouvons trouver le détail complet dans l'article deIntroduction to Spring Data JPA.

Spring Data LDAP fournit une abstraction similaire qui fournit l'implémentation automatique des interfacesRepository qui incluent une opération CRUD de base pour les annuaires LDAP.

En outre, Spring Data Framework peut créer uncustom query basé sur un nom de méthode.

Définissons notre interface de référentiel qui sera utilisée pour gérerUser Entry: 

@Repository
public interface UserRepository extends LdapRepository {
    User findByUsername(String username);
    User findByUsernameAndPassword(String username, String password);
    List findByUsernameLikeIgnoreCase(String username);
}

Comme nous pouvons le voir, nous avons déclaré une interface en étendantLdapRepository pour l'entréeUser. Spring Data Framework fournira automatiquement une implémentation de base de la méthode CRUD telle quefind(),findAll(),save(),delete(), etc.

En outre, nous avons déclaré quelques méthodes personnalisées. Spring Data Framework fournira l'implémentation en sondant le nom de la méthode avec une stratégie connue sous le nom deQuery Builder Mechanism.

5. Configuration

Nous pouvons configurer Spring Data LDAP à l'aide de classes@Configuration basées sur Java ou d'un espace de noms XML. Configurons le référentiel à l’aide de l’approche basée sur Java: 

@Configuration
@EnableLdapRepositories(basePackages = "com.example.ldap.**")
public class AppConfig {
}

@EnableLdapRepositories indique à Spring de scanner le package donné pour les interfaces marquées comme@Repository.

6. Logique d'entreprise

Définissons notre classe de service qui utilisera lesUserRepository pour fonctionner sur les annuaires LDAP: 

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;

    // business methods
}

Nous allons maintenant explorer une action à la fois et voir à quel point il est facile de les réaliser à l'aide de Spring Data Repository.

6.1. Authentification d'utilisateur

Implémentons maintenant une simple logique pour authentifier un utilisateur existant: 

public Boolean authenticate(String u, String p) {
    return userRepository.findByUsernameAndPassword(u, p) != null;
}

6.2. Création d'utilisateur

Ensuite, créons un nouvel utilisateur et stockons le hachage d'un mot de passe: 

public void create(String username, String password) {
    User newUser = new User(username,digestSHA(password));
    newUser.setId(LdapUtils.emptyLdapName());
    userRepository.save(newUser);
}

6.3. Modification de l'utilisateur

Nous pouvons modifier un utilisateur ou une entrée existante avec la méthode suivante: 

public void modify(String u, String p) {
    User user = userRepository.findByUsername(u);
    user.setPassword(p);
    userRepository.save(user);
}

6.4. Recherche d'utilisateurs

Nous pouvons rechercher des utilisateurs existants en utilisant une méthode personnalisée: 

public List search(String u) {
    List userList = userRepository
      .findByUsernameLikeIgnoreCase(u);

    if (userList == null) {
        return Collections.emptyList();
    }

    return userList.stream()
      .map(User::getUsername)
      .collect(Collectors.toList());
}

7. Exemple en action

Enfin, nous pouvons rapidement tester un scénario d’authentification simple: 

@Test
public void givenLdapClient_whenCorrectCredentials_thenSuccessfulLogin() {
    Boolean isValid = userService.authenticate(USER3, USER3_PWD);

    assertEquals(true, isValid);
}

8. Conclusion

Ce didacticiel rapide a présenté les bases de la configuration du référentiel Spring LDAP et du fonctionnement de CRUD.

L'exemple utilisé dans cet article peut être trouvéover on GitHub.

Related