Java équivalent aux méthodes d'extension C #

Je cherche à implémenter une fonctionnalité dans une liste d'objets comme je le ferais en C # en utilisant une méthode d'extension.

Quelque chose comme ça:

List<DataObject> list;
// ... List initialization.
list.getData(id);

Comment faire cela en Java?

Java ne prend pas en charge les méthodes d'extension.

Au lieu de cela, vous pouvez créer une méthode statique régulière ou écrire votre propre classe.

Les méthodes d'extension ne sont pas seulement des méthodes statiques et pas seulement du sucre de syntaxe pratique, en fait, elles sont des outils assez puissants. L'essentiel est de pouvoir remplacer différentes méthodes basées sur l'instanciation de différents paramètres génériques. Ceci est similaire aux classes de types de Haskell, et en fait, il semble qu'elles soient en C # pour supporter les monades de C # (c'est-à-dire LINQ). Même en abandonnant la syntaxe LINQ, je ne connais toujours aucun moyen d'implémenter des interfaces similaires en Java.

Et je ne pense pas qu'il soit possible de les implémenter en Java, à cause de la sémantique d'effacement de type Java des paramètres génériques.

Project Lombok fournit une annotation @ExtensionMethodqui peut être utilisée pour obtenir la fonctionnalité que vous demandez.

Techniquement, l'extension C # n'a pas d'équivalent en Java. Mais si vous souhaitez implémenter de telles fonctions pour un code plus propre et une maintenabilité, vous devez utiliser le framework Manifold.

package extensions.java.lang.String;

import manifold.ext.api.*;

@Extension
public class MyStringExtension {

  public static void print(@This String thiz) {
    System.out.println(thiz);
  }

  @Extension
  public static String lineSeparator() {
    return System.lineSeparator();
  }
}

Le langage XTend - qui est un super-ensemble de Java, et se compile en code source Java ¹  - le prend en charge.

Manifold fournit à Java des méthodes d'extension de style C # et plusieurs autres fonctionnalités. Contrairement à d' autres outils, collecteur n'a pas de limites et ne pas souffrir de problèmes avec les génériques, lambdas, etc. IDE fournit plusieurs Manifold d' autres fonctions telles que F # -style types personnalisés , tapuscrit de style interfaces de structure et de style Javascript types expando .

De plus, IntelliJ fournit une prise en charge complète de Manifold via le plugin Manifold .

Manifold est un projet open source disponible sur github .

Une autre option consiste à utiliser les classes ForwardingXXX de la bibliothèque google-guava.

Java n'a pas une telle fonctionnalité. Au lieu de cela, vous pouvez créer une sous-classe régulière de votre implémentation de liste ou créer une classe interne anonyme:

List<String> list = new ArrayList<String>() {
   public String getData() {
       return ""; // add your implementation here. 
   }
};

Le problème est d'appeler cette méthode. Vous pouvez le faire "sur place":

new ArrayList<String>() {
   public String getData() {
       return ""; // add your implementation here. 
   }
}.getData();

Il semble qu'il y a peu de chances que les méthodes Defender (c'est-à-dire les méthodes par défaut) soient intégrées à Java 8. Cependant, pour autant que je les comprends, elles permettent uniquement à l' auteur d'un interfacede l'étendre rétroactivement, pas aux utilisateurs arbitraires.

Defender Methods + Interface Injection serait alors capable d'implémenter pleinement les méthodes d'extension de style C #, mais AFAICS, Interface Injection n'est même pas encore sur la feuille de route de Java 8.

Un peu tard à la fête sur cette question, mais au cas où quelqu'un le trouverait utile, je viens de créer une sous-classe:

public class ArrayList2<T> extends ArrayList<T> 
{
    private static final long serialVersionUID = 1L;

    public T getLast()
    {
        if (this.isEmpty())
        {
            return null;
        }
        else
        {       
            return this.get(this.size() - 1);
        }
    }
}

Nous pouvons simuler l'implémentation des méthodes d'extension C # en Java en utilisant l'implémentation de méthode par défaut disponible depuis Java 8. Nous commençons par définir une interface qui nous permettra d'accéder à l'objet support via une méthode base (), comme ceci:

public interface Extension<T> {

    default T base() {
        return null;
    }
}

Nous retournons null car les interfaces ne peuvent pas avoir d'état, mais cela doit être corrigé ultérieurement via un proxy.

Le développeur d'extensions devrait étendre cette interface par une nouvelle interface contenant des méthodes d'extension. Disons que nous voulons ajouter une interface forEach consumer sur List:

public interface ListExtension<T> extends Extension<List<T>> {

    default void foreach(Consumer<T> consumer) {
        for (T item : base()) {
            consumer.accept(item);
        }
    }

}

Comme nous étendons l'interface d'extension, nous pouvons appeler la méthode base () dans notre méthode d'extension pour accéder à l'objet de support auquel nous nous attachons.

L'interface d'extension doit avoir une méthode de fabrique qui créera une extension d'un objet de support donné:

public interface Extension<T> {

    ...

    static <E extends Extension<T>, T> E create(Class<E> type, T instance) {
        if (type.isInterface()) {
            ExtensionHandler<T> handler = new ExtensionHandler<T>(instance);
            List<Class<?>> interfaces = new ArrayList<Class<?>>();
            interfaces.add(type);
            Class<?> baseType = type.getSuperclass();
            while (baseType != null && baseType.isInterface()) {
                interfaces.add(baseType);
                baseType = baseType.getSuperclass();
            }
            Object proxy = Proxy.newProxyInstance(
                    Extension.class.getClassLoader(),
                    interfaces.toArray(new Class<?>[interfaces.size()]),
                    handler);
            return type.cast(proxy);
        } else {
            return null;
        }
    }
}

Nous créons un proxy qui implémente l'interface d'extension et toute l'interface implémentée par le type de l'objet de support. Le gestionnaire d'appel donné au proxy distribuerait tous les appels à l'objet de support, à l'exception de la méthode "base", qui doit renvoyer l'objet de support, sinon son implémentation par défaut renvoie null:

public class ExtensionHandler<T> implements InvocationHandler {

    private T instance;

    private ExtensionHandler(T instance) {
        this.instance = instance;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        if ("base".equals(method.getName())
                && method.getParameterCount() == 0) {
            return instance;
        } else {
            Class<?> type = method.getDeclaringClass();
            MethodHandles.Lookup lookup = MethodHandles.lookup()
                .in(type);
            Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
            makeFieldModifiable(allowedModesField);
            allowedModesField.set(lookup, -1);
            return lookup
                .unreflectSpecial(method, type)
                .bindTo(proxy)
                .invokeWithArguments(args);
        }
    }

    private static void makeFieldModifiable(Field field) throws Exception {
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        modifiersField
                .setInt(field, field.getModifiers() & ~Modifier.FINAL);
    }

}

Ensuite, nous pouvons utiliser la méthode Extension.create () pour attacher l'interface contenant la méthode d'extension à l'objet de support. Le résultat est un objet qui peut être transtypé vers l'interface d'extension par laquelle nous pouvons toujours accéder à l'objet de support appelant la méthode base (). Une fois la référence castée vers l'interface d'extension, nous pouvons maintenant appeler en toute sécurité les méthodes d'extension qui peuvent avoir accès à l'objet de support, de sorte que nous pouvons maintenant attacher de nouvelles méthodes à l'objet existant, mais pas à son type de définition:

public class Program {

    public static void main(String[] args) {
        List<String> list = Arrays.asList("a", "b", "c");
        ListExtension<String> listExtension = Extension.create(ListExtension.class, list);
        listExtension.foreach(System.out::println);
    }

}

C'est donc une façon de simuler la capacité d'étendre des objets en Java en leur ajoutant de nouveaux contrats, ce qui nous permet d'appeler des méthodes supplémentaires sur les objets donnés.

Vous trouverez ci-dessous le code de l'interface d'extension:

import java.lang.reflect.Field;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;

public interface Extension<T> {

    public class ExtensionHandler<T> implements InvocationHandler {

        private T instance;

        private ExtensionHandler(T instance) {
            this.instance = instance;
        }

        @Override
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            if ("base".equals(method.getName())
                    && method.getParameterCount() == 0) {
                return instance;
            } else {
                Class<?> type = method.getDeclaringClass();
                MethodHandles.Lookup lookup = MethodHandles.lookup()
                    .in(type);
                Field allowedModesField = lookup.getClass().getDeclaredField("allowedModes");
                makeFieldModifiable(allowedModesField);
                allowedModesField.set(lookup, -1);
                return lookup
                    .unreflectSpecial(method, type)
                    .bindTo(proxy)
                    .invokeWithArguments(args);
            }
        }

        private static void makeFieldModifiable(Field field) throws Exception {
            field.setAccessible(true);
            Field modifiersField = Field.class.getDeclaredField("modifiers");
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        }

    }

    default T base() {
        return null;
    }

    static <E extends Extension<T>, T> E create(Class<E> type, T instance) {
        if (type.isInterface()) {
            ExtensionHandler<T> handler = new ExtensionHandler<T>(instance);
            List<Class<?>> interfaces = new ArrayList<Class<?>>();
            interfaces.add(type);
            Class<?> baseType = type.getSuperclass();
            while (baseType != null && baseType.isInterface()) {
                interfaces.add(baseType);
                baseType = baseType.getSuperclass();
            }
            Object proxy = Proxy.newProxyInstance(
                    Extension.class.getClassLoader(),
                    interfaces.toArray(new Class<?>[interfaces.size()]),
                    handler);
            return type.cast(proxy);
        } else {
            return null;
        }
    }

}

On pourrait utiliser le modèle de conception orienté objet du décorateur . Un exemple de ce modèle utilisé dans la bibliothèque standard de Java serait le DataOutputStream .

Voici du code pour augmenter les fonctionnalités d'une liste:

public class ListDecorator<E> implements List<E>
{
    public final List<E> wrapee;

    public ListDecorator(List<E> wrapee)
    {
        this.wrapee = wrapee;
    }

    // implementation of all the list's methods here...

    public <R> ListDecorator<R> map(Transform<E,R> transformer)
    {
        ArrayList<R> result = new ArrayList<R>(size());
        for (E element : this)
        {
            R transformed = transformer.transform(element);
            result.add(transformed);
        }
        return new ListDecorator<R>(result);
    }
}

PS Je suis un grand fan de Kotlin . Il a des méthodes d'extension et fonctionne également sur la JVM.

Vous pouvez créer une méthode d'extension / d'assistance de type C # en (RE) implémentant l'interface Collections et en ajoutant un exemple pour Java Collection:

public class RockCollection<T extends Comparable<T>> implements Collection<T> {
private Collection<T> _list = new ArrayList<T>();

//###########Custom extension methods###########

public T doSomething() {
    //do some stuff
    return _list  
}

//proper examples
public T find(Predicate<T> predicate) {
    return _list.stream()
            .filter(predicate)
            .findFirst()
            .get();
}

public List<T> findAll(Predicate<T> predicate) {
    return _list.stream()
            .filter(predicate)
            .collect(Collectors.<T>toList());
}

public String join(String joiner) {
    StringBuilder aggregate = new StringBuilder("");
    _list.forEach( item ->
        aggregate.append(item.toString() + joiner)
    );
    return aggregate.toString().substring(0, aggregate.length() - 1);
}

public List<T> reverse() {
    List<T> listToReverse = (List<T>)_list;
    Collections.reverse(listToReverse);
    return listToReverse;
}

public List<T> sort(Comparator<T> sortComparer) {
    List<T> listToReverse = (List<T>)_list;
    Collections.sort(listToReverse, sortComparer);
    return listToReverse;
}

public int sum() {
    List<T> list = (List<T>)_list;
    int total = 0;
    for (T aList : list) {
        total += Integer.parseInt(aList.toString());
    }
    return total;
}

public List<T> minus(RockCollection<T> listToMinus) {
    List<T> list = (List<T>)_list;
    int total = 0;
    listToMinus.forEach(list::remove);
    return list;
}

public Double average() {
    List<T> list = (List<T>)_list;
    Double total = 0.0;
    for (T aList : list) {
        total += Double.parseDouble(aList.toString());
    }
    return total / list.size();
}

public T first() {
    return _list.stream().findFirst().get();
            //.collect(Collectors.<T>toList());
}
public T last() {
    List<T> list = (List<T>)_list;
    return list.get(_list.size() - 1);
}
//##############################################
//Re-implement existing methods
@Override
public int size() {
    return _list.size();
}

@Override
public boolean isEmpty() {
    return _list == null || _list.size() == 0;
}

Java8 prend désormais en charge les méthodes par défaut , qui sont similaires aux C#méthodes d'extension de.