Examen de Java Inside - 2025 - session 1

Exercice 1 - Property Mapper

      server.port=8080
      server.host=localhost
    

import java.util.Properties;
import java.io.IOError;
import java.io.IOException;
import java.io.StringReader;

public final class PropertyMapper {
  private final Properties properties;

  private PropertyMapper(Properties properties) {
    this.properties = properties;
    super();
  }

  public static PropertyMapper create(Properties properties) {
    Objects.requireNonNull(properties);
    return new PropertyMapper(properties);  // no defensive copy
  }

  public static PropertyMapper create(String propertyText) {
    Objects.requireNonNull(propertyText);
    var properties = new Properties();
    try(var reader = new StringReader(propertyText)) {
      properties.load(reader);
    } catch (IOException e) {
      throw new IOError(e);
    }
    return create(properties);
  }

  // TODO
    

1. On cherche dans un premier temps à implanter la méthode extract(prefix, beanType). qui renvoie un objet Java Bean de la classe prise en paramètre.
   L'algorithme est le suivant, le constructeur sans paramètre du beanType est appelé puis pour chaque property descriptor, la propriété correspondante est cherchée dans l'objet java.util.Properties (avec le préfixe), si la propriété possède une valeur associé alors le setter est appelé avec la valeur de la propriété.
   Pour l'instant, on ne va implanter le support que des propriétés dont les valeurs sont des chaines de caractères.
   Écrire la méthode extract(prefix, beanType).
   Vérifier que les tests unitaires marqués "Q1" passent.


2. On souhaite que extract fonctionne aussi si le préfixe est "".
   Modifier si nécessaire le code de la méthode extract.
   Vérifier que les tests unitaires marqués "Q2" passent.


3. On souhaite maintenant écrire la méthode proxy(prefix, beanType).
   L'algorithme est un peu différent. Lors de l'appel à la méthode proxy, le proxy est créé indépendamment du fait que les propriétés sous-jacentes existe ou pas. En effet, on peut créer les propriétés en appelant les setter de l'objet.
   Lorsqu'un getter est appelé, la propriété correspondante (en prenant en compte le préfixe) est recherchée et sa valeur est retournée (null peut être renvoyé si la propriété n'existe pas).
   Lorsqu'un setter est appelé, la propriété correspondante est écrit dans l'objet java.util.Properties.
   Ecrire le code de la méthode proxy(prefix, beanType) sachant que, pour l'instant, on veut uniquement que les getter marche.
   Vérifier que les tests unitaires marqués "Q3" passent.


4. Modifier votre code pour que les setter du proxy fonctionnent aussi.
   Vérifier que les tests unitaires marqués "Q4" passent.


5. En fait, on veut maintenant une implantation efficace des getter et setter. Pour cela, on va utiliser un dictionnaire qui associe à l'objet java.lang.reflect.Method, une fonction qui execute le code du getter ou du setter.
   Le code de l'InvocationHandler devrait donc être
   

   var op = propertyMap.get(method);
   if (op != null) {
     return op.apply(args == null ? null : args[0]);
   }
   throw new UnsupportedOperationException("Method not supported: " + method);
       

   
   Faites les changements qui s'imposent dans votre code. Les tests unitaires devraient continuer de passer.
   Note: si vous n'y arrivez pas, vous pouvez passer à la question suivante.


6. On souhaite que si getter renvoie une interface, alors le getter renvoie un nouvel objet proxy qui permet de voir les propriétés qui commence par le même sous préfixe.
   Par exemple, on souhaite que le code suivant fonctionne

   public interface Address {
     String getStreet();
   }
   public interface Person {
     String getName();
     Address getAddress();  // returns an interface
   }
   ...
     var propertyText = """
         user.name=Alice
         user.address.street=32 canyon road
         """;
     var mapper = PropertyMapper.create(propertyText);
     var person = mapper.proxy("user",  Person.class);
     var address = person.getAddress();  // returns a new proxy
   
     IO.println(person.getName());     // Alice
     IO.println(address.getStreet());  // 32 canyon road
       

   
   Modifier votre code pour que cela fonctionne.
   Vérifier que les tests unitaires marqués "Q6" passent.
   Note: en termes de performance, vous ne devriez créer l'objet proxy correspondant à une adresse que si nécessaire.


7. On souhaite ajouter une méthode freeze() qui interdit toutes modifications ultérieures des propriétés par les setter des proxies (même si ceux-ci ont été créés avant).
   Écrire la méthode freeze.
   Vérifier que les tests unitaires marqués "Q7" passent.


8. Enfin, on veut que les Java Bean et les proxies fonctionnent avec des types primitifs.
   Modifier votre implantation en conséquence.
   Vérifier que les tests unitaires marqués "Q8" passent.
   Note: pour le type char, la chaine de caractères correspondante devra avoir un seul caractère !