Protokollierung das Ergebnis der filter während der Verwendung von java streams filter-Prädikat

Das Szenario ist, es gibt verschiedene Arten von filtern, die ich geschaffen habe, welche Filter die Liste der einige Objekte auf der Grundlage der Eigenschaft des Objekts.

Also für das, dass ich erstellt habe, eine AbstractObjectFilter Klasse, die geerbt, die von jedem filter.

AbstractObjectFilter.java

public abstract class AbstractEventFilter
{
    protected abstract Predicate<IEvent> isEligible();

    public List<IEvent> getFilteredEvents(final List<IEvent> events)
    {
        return events.stream().filter(isEligible()).collect(Collectors.toList());
    }
}

So, jetzt jeden filter erweitert diese Klasse und überschreibt die isEligible() und in dieser Funktion zurückgegeben, die das Prädikat basiert auf seinen Eigenschaften.

ZB:-
MinNumOfPrizesFilter.java 

public class MinimumNumOfPrizesFilter extends AbstractEventFilter
{
    private int minimumNumOfPrizes;

    public MinimumNumOfPrizesFilter(@NonNull int minimumNumOfPrizes)
    {
        this.minimumNumOfPrizes = minimumNumOfPrizes;
    }

    @Override
    protected Predicate<IEvent> isEligible()
    {
        return event -> event.getPrizeCount() >= minimumNumOfPrizes;
    }
}

Ebenso gibt es viele andere Filter, die ich erstellt habe. Es ist eine applyFilter-Funktion, die Iteration über die Liste von filter-Objekten und halten die Anwendung filter-by-call getFilteredEvents Funktion.

Nun, wie kann ich mich anmelden das Schicksal der einzelnen Ereignis-Zum Beispiel - "x1 Ereignis gefiltert wurde, MinNumOfPrizesFilter filter. x1 Preis zu zählen - 10 , erforderlich min-Preis - count 20"

  • Was ist der Punkt, der den lambda-Ausdruck hier? Im Vergleich zu den konventionellen Ansatz, der nur lassen AbstractEventFilter implementieren Predicate<IEvent> direkt, so dass Sie in Unterklassen nur um die Umsetzung der test Methode, es ist nicht eine Vereinfachung.
  • Übrigens, es ist sinnlos zu kommentieren ein int variable mit @NonNull als int Werte können nie null sowieso.
InformationsquelleAutor rcipher222 | 2017-04-22
  1. 8

    Können Sie einfach fügen Sie Klammern an Ihren lambda-Ausdruck, und fügen Sie die logging-Anweisung direkt vor der Validierung :

    return event -> {
    //LOG.info(event.getName() + " was filtered...") or whatever you use for logging.
    return event.getPrizeCount() >= minimumNumOfPrizes;
}

    Beachten Sie, dass es einen peek operation, die verwendet werden sollen, meist für die Anmeldung java streams :

    events.stream()
      .peek(event -> System.out.println("Filtering event" + event.getName()))
      .filter(isEligible())
      .collect(Collectors.toList());

    aber, dass ist nicht zu helfen hier, wie Sie brauchen, um sich in AbstractEventFilter Implementierungen.

    • mit diesem Sie die Protokollierung der gefilterten und der ungefilterten Werte
    • Ich weiß, dass. Der Lesevorgang nicht passt hier, nur fügte hinzu, es informationell, da ist es oft hilfreich für die Protokollierung mit Hilfe von java-streams.
    • und Sie müssen, um es zu implementieren, die in jeder abgeleiteten Klasse
    • Da die Prädikate unterscheiden sich in der Durchführung, und OP drucken möchten diese Informationen (ich.e minimumNumOfPrizes), ist dies erforderlich.
    InformationsquelleAutor Jean-François Savard
  2. 2

    vielleicht nicht die hübscheste Lösung, aber es funktioniert und Sie ändern nur Ihre abstrakte Basis-Klasse:

    abstract class AbstractEventFilter {

    private final Logger logger = Logger.getLogger(getClass().getCanonicalName());
    private final String filterName = getClass().getSimpleName();

    protected abstract Predicate<IEvent> isEligible();

    private Predicate<IEvent> internalIsEligible() {
        return iEvent -> {
            boolean res = isEligible().test(iEvent);
            if (!res) {
                logger.info("event " + iEvent.toString() + " filtered by " + filterName);
            }
            return res;
        };
    }

    public List<IEvent> getFilteredEvents(final List<IEvent> events) {
        return events.stream().filter(internalIsEligible()).collect(Collectors.toList());
    }
}

    halten Sie Ihre abgeleiteten Klassen implementieren isELigible() wie vorher, nur in Ihrer getFilteredEvents - Methode, rufen Sie die internalIsEligibable Methode statt.

    • Wie drucken Sie die minimumNumOfPrizes ?
    • Upvote nur für die Protokollierung diejenigen, die gefiltert.
    InformationsquelleAutor P.J.Meisch
Schreibe einen Kommentar