Java Language Utilizzo delle interfacce con Generics

Esempio

Supponiamo che tu voglia definire un'interfaccia che consenta la pubblicazione / il consumo di dati da e verso diversi tipi di canali (ad es. AMQP, JMS, ecc.), Ma tu vuoi essere in grado di cambiare i dettagli di implementazione ...

Definiamo un'interfaccia IO di base che può essere riutilizzata in più implementazioni:

public interface IO<IncomingType, OutgoingType> {

    void publish(OutgoingType data);
    IncomingType consume();
    IncomingType RPCSubmit(OutgoingType data);

}

Ora posso creare un'istanza di questa interfaccia, ma dal momento che non abbiamo implementazioni predefinite per questi metodi, avrà bisogno di un'implementazione quando la istanziamo:

    IO<String, String> mockIO = new IO<String, String>() {

        private String channel = "somechannel";

        @Override
        public void publish(String data) {
            System.out.println("Publishing " + data + " to " + channel);
        }

        @Override
        public String consume() {
            System.out.println("Consuming from " + channel);
            return "some useful data";
        }

        @Override
        public String RPCSubmit(String data) {
            return "received " + data + " just now ";
        }

    };

    mockIO.consume(); // prints: Consuming from somechannel
    mockIO.publish("TestData"); // Publishing TestData to somechannel
    System.out.println(mockIO.RPCSubmit("TestData")); // received TestData just now

Possiamo anche fare qualcosa di più utile con quell'interfaccia, diciamo che vogliamo usarlo per avvolgere alcune funzioni base di RabbitMQ:

public class RabbitMQ implements IO<String, String> {

    private String exchange;
    private String queue;

    public RabbitMQ(String exchange, String queue){
        this.exchange = exchange;
        this.queue = queue;
    }

    @Override
    public void publish(String data) {
        rabbit.basicPublish(exchange, queue, data.getBytes());
    }

    @Override
    public String consume() {
        return rabbit.basicConsume(exchange, queue);
    }

    @Override
    public String RPCSubmit(String data) {
        return rabbit.rpcPublish(exchange, queue, data);
    }

}

Diciamo che voglio usare questa interfaccia IO ora come un modo per contare le visite al mio sito web dal mio ultimo riavvio del sistema e quindi essere in grado di visualizzare il numero totale di visite - puoi fare qualcosa del genere:

import java.util.concurrent.atomic.AtomicLong;

public class VisitCounter implements IO<Long, Integer> {

    private static AtomicLong websiteCounter = new AtomicLong(0);
    
    @Override
    public void publish(Integer count) {
        websiteCounter.addAndGet(count);
    }

    @Override
    public Long consume() {
        return websiteCounter.get();
    }

    @Override
    public Long RPCSubmit(Integer count) {
        return websiteCounter.addAndGet(count);
    }
    
}

Ora usiamo il VisitCounter:

    VisitCounter counter = new VisitCounter();

    // just had 4 visits, yay
    counter.publish(4);
    // just had another visit, yay
    counter.publish(1);

    // get data for stats counter
    System.out.println(counter.consume()); // prints 5

    // show data for stats counter page, but include that as a page view
    System.out.println(counter.RPCSubmit(1)); // prints 6

Quando si implementano più interfacce, non è possibile implementare la stessa interfaccia due volte. Questo vale anche per le interfacce generiche. Pertanto, il seguente codice non è valido e genererà un errore di compilazione:

interface Printer<T> {
    void print(T value);
}

// Invalid!
class SystemPrinter implements Printer<Double>, Printer<Integer> {
    @Override public void print(Double d){ System.out.println("Decimal: " + d); }
    @Override public void print(Integer i){ System.out.println("Discrete: " + i); }
}