From a074f93e10a0893fcd37bfdbf03351268eba4934 Mon Sep 17 00:00:00 2001 From: David Belmez Vicente Date: Tue, 26 Sep 2017 21:01:57 +0200 Subject: [PATCH] [slf4j]: Use SLF4J (#114) Use SLF4J instead of JUL --- easy-rules-core/pom.xml | 4 + .../jeasy/rules/core/DefaultRuleListener.java | 28 +++---- .../jeasy/rules/core/DefaultRulesEngine.java | 74 +++++++++++-------- .../jeasy/rules/core/RulesEngineBuilder.java | 14 ++-- .../rules/core/RulesEngineParameters.java | 56 ++++++++------ .../main/java/org/jeasy/rules/core/Utils.java | 41 ---------- .../src/main/resources/logging.properties | 4 - .../rules/core/DefaultRulesEngineTest.java | 19 ++--- .../rules/core/RulesEngineBuilderTest.java | 8 +- .../fizzbuzz/FizzBuzzWithEasyRules.java | 5 +- .../web/SuspiciousRequestFilter.java | 20 +++-- pom.xml | 9 ++- 12 files changed, 136 insertions(+), 146 deletions(-) delete mode 100644 easy-rules-core/src/main/resources/logging.properties diff --git a/easy-rules-core/pom.xml b/easy-rules-core/pom.xml index ba45db9..cbc001d 100644 --- a/easy-rules-core/pom.xml +++ b/easy-rules-core/pom.xml @@ -50,6 +50,10 @@ + + org.slf4j + slf4j-api + junit junit diff --git a/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRuleListener.java b/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRuleListener.java index 25f7002..b8df9a8 100644 --- a/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRuleListener.java +++ b/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRuleListener.java @@ -27,40 +27,42 @@ import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.Rule; import org.jeasy.rules.api.RuleListener; -import java.util.logging.Level; -import java.util.logging.Logger; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; class DefaultRuleListener implements RuleListener { - private static final Logger LOGGER = Logger.getLogger(DefaultRuleListener.class.getName()); + private static final Logger LOGGER = LoggerFactory.getLogger(DefaultRuleListener.class); @Override - public boolean beforeEvaluate(Rule rule, Facts facts) { + public boolean beforeEvaluate(final Rule rule, final Facts facts) { return true; } @Override - public void afterEvaluate(Rule rule, Facts facts, boolean evaluationResult) { - String ruleName = rule.getName(); + public void afterEvaluate(final Rule rule, final Facts facts, final boolean evaluationResult) { + final String ruleName = rule.getName(); if (evaluationResult) { - LOGGER.log(Level.INFO, "Rule ''{0}'' triggered", ruleName); + LOGGER.info("Rule ''{}'' triggered", ruleName); } else { - LOGGER.log(Level.INFO, "Rule ''{0}'' has been evaluated to false, it has not been executed", ruleName); + LOGGER.info("Rule ''{}'' has been evaluated to false, it has not been executed", ruleName); } } @Override - public void beforeExecute(Rule rule, Facts facts) { + public void beforeExecute(final Rule rule, final Facts facts) { } @Override - public void onSuccess(Rule rule, Facts facts) { - LOGGER.log(Level.INFO, "Rule ''{0}'' performed successfully", rule.getName()); + public void onSuccess(final Rule rule, final Facts facts) { + LOGGER.info("Rule ''{}'' performed successfully", rule.getName()); } @Override - public void onFailure(Rule rule, Facts facts, Exception exception) { - LOGGER.log(Level.SEVERE, String.format("Rule '%s' performed with error", rule.getName()), exception); + public void onFailure(final Rule rule, final Facts facts, final Exception exception) { + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Rule '" + rule.getName() + "' performed with error", exception); + } } } diff --git a/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java b/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java index 39b7cd8..37220cb 100644 --- a/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java +++ b/easy-rules-core/src/main/java/org/jeasy/rules/core/DefaultRulesEngine.java @@ -23,13 +23,17 @@ */ package org.jeasy.rules.core; -import org.jeasy.rules.api.*; - -import java.util.*; -import java.util.logging.Level; -import java.util.logging.Logger; - -import static java.lang.String.format; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import org.jeasy.rules.api.Facts; +import org.jeasy.rules.api.Rule; +import org.jeasy.rules.api.RuleListener; +import org.jeasy.rules.api.Rules; +import org.jeasy.rules.api.RulesEngine; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; /** * Default {@link RulesEngine} implementation. @@ -42,7 +46,7 @@ import static java.lang.String.format; */ public final class DefaultRulesEngine implements RulesEngine { - private static final Logger LOGGER = Logger.getLogger(RulesEngine.class.getName()); + private static final Logger LOGGER = LoggerFactory.getLogger(DefaultRuleListener.class); /** * The engine parameters @@ -81,9 +85,6 @@ public final class DefaultRulesEngine implements RulesEngine { this.ruleListeners = new ArrayList<>(); this.ruleListeners.add(new DefaultRuleListener()); this.ruleListeners.addAll(ruleListeners); - if (parameters.isSilentMode()) { - Utils.muteLoggers(); - } } @Override @@ -99,7 +100,7 @@ public final class DefaultRulesEngine implements RulesEngine { @Override public void fire(Rules rules, Facts facts) { if (rules.isEmpty()) { - LOGGER.warning("No rules registered! Nothing to apply"); + LOGGER.warn("No rules registered! Nothing to apply"); return; } logEngineParameters(); @@ -126,13 +127,13 @@ public final class DefaultRulesEngine implements RulesEngine { final String name = rule.getName(); final int priority = rule.getPriority(); if (priority > parameters.getPriorityThreshold()) { - LOGGER.log(Level.INFO, - "Rule priority threshold ({0}) exceeded at rule ''{1}'' with priority={2}, next rules will be skipped", - new Object[]{parameters.getPriorityThreshold(), name, priority}); + LOGGER.info("Rule priority threshold ({}) exceeded at rule ''{}'' with priority={}, next rules will be skipped", + parameters.getPriorityThreshold(), name, priority); break; } if (!shouldBeEvaluated(rule, facts)) { - LOGGER.log(Level.INFO, "Rule ''{0}'' has been skipped before being evaluated", name); + LOGGER.info("Rule ''{}'' has been skipped before being evaluated", + name); continue; } boolean evaluationResult; @@ -140,7 +141,8 @@ public final class DefaultRulesEngine implements RulesEngine { evaluationResult = rule.evaluate(facts); } catch (NoSuchFactException e) { if (parameters.isSkipOnMissingFact()) { - LOGGER.log(Level.INFO, "Rule ''{0}'' has been skipped due to missing fact ''{1}''", new Object[]{name, e.getMissingFact()}); + LOGGER.info("Rule ''{}'' has been skipped due to missing fact ''{}''", + name, e.getMissingFact()); continue; } else { throw new RuntimeException(e); @@ -211,29 +213,37 @@ public final class DefaultRulesEngine implements RulesEngine { } private void logEngineParameters() { - LOGGER.log(Level.INFO, "Rule priority threshold: {0}", parameters.getPriorityThreshold()); - LOGGER.log(Level.INFO, "Skip on first applied rule: {0}", parameters.isSkipOnFirstAppliedRule()); - LOGGER.log(Level.INFO, "Skip on first non triggered rule: {0}", parameters.isSkipOnFirstNonTriggeredRule()); - LOGGER.log(Level.INFO, "Skip on first failed rule: {0}", parameters.isSkipOnFirstFailedRule()); - LOGGER.log(Level.INFO, "Skip on missing fact: {0}", parameters.isSkipOnMissingFact()); + LOGGER.info("Rule priority threshold: {}", + parameters.getPriorityThreshold()); + LOGGER.info("Skip on first applied rule: {}", + parameters.isSkipOnFirstAppliedRule()); + LOGGER.info("Skip on first non triggered rule: {}", + parameters.isSkipOnFirstNonTriggeredRule()); + LOGGER.info("Skip on first failed rule: {}", + parameters.isSkipOnFirstFailedRule()); + LOGGER.info("Skip on missing fact: {}", + parameters.isSkipOnMissingFact()); } private void log(Rules rules) { - LOGGER.log(Level.INFO, "Registered rules:"); - for (Rule rule : rules) { - LOGGER.log(Level.INFO, format("Rule { name = '%s', description = '%s', priority = '%s'}", - rule.getName(), rule.getDescription(), rule.getPriority())); + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Registered rules:"); + for (Rule rule : rules) { + LOGGER.info("Rule { name = '{}', description = '{}', priority = '{}'}", + rule.getName(), rule.getDescription(), rule.getPriority()); + } } } private void log(Facts facts) { - LOGGER.log(Level.INFO, "Known facts:"); - for (Map.Entry fact : facts) { - LOGGER.log(Level.INFO, format("Fact { %s : %s }", + if (LOGGER.isInfoEnabled()) { + LOGGER.info("Known facts:"); + for (Map.Entry fact : facts) { + LOGGER.info("Fact { {} : {} }", fact.getKey(), - fact.getValue() == null ? "null" : fact.getValue().toString()) - ); + fact.getValue() == null ? "null" : fact.getValue().toString() + ); + } } } - } diff --git a/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineBuilder.java b/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineBuilder.java index 9f4e6f7..d1e38bc 100644 --- a/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineBuilder.java +++ b/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineBuilder.java @@ -36,9 +36,9 @@ import java.util.List; */ public class RulesEngineBuilder { - private RulesEngineParameters parameters; + private final RulesEngineParameters parameters; - private List ruleListeners; + private final List ruleListeners; /** * Create a new rules engine builder. @@ -50,7 +50,7 @@ public class RulesEngineBuilder { } private RulesEngineBuilder() { - parameters = new RulesEngineParameters(false, false, false, false, RulesEngineParameters.DEFAULT_RULE_PRIORITY_THRESHOLD, false); + parameters = new RulesEngineParameters(false, false, false, false, RulesEngineParameters.DEFAULT_RULE_PRIORITY_THRESHOLD); ruleListeners = new ArrayList<>(); } @@ -121,13 +121,11 @@ public class RulesEngineBuilder { } /** - * Set silent mode to mute all loggers. - * - * @param silentMode to set - * @return the rules engine builder + * @deprecated Silent mode is now log implementation config. Now it uses slf4j facade + * This will be removed in v3.2 */ + @Deprecated public RulesEngineBuilder withSilentMode(final boolean silentMode) { - parameters.setSilentMode(silentMode); return this; } diff --git a/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineParameters.java b/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineParameters.java index 373494e..9332b26 100644 --- a/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineParameters.java +++ b/easy-rules-core/src/main/java/org/jeasy/rules/core/RulesEngineParameters.java @@ -33,7 +33,7 @@ public class RulesEngineParameters { /** * Default rule priority threshold. */ - public static int DEFAULT_RULE_PRIORITY_THRESHOLD = Integer.MAX_VALUE; + public static final int DEFAULT_RULE_PRIORITY_THRESHOLD = Integer.MAX_VALUE; /** * Parameter to skip next applicable rules when a rule is applied. @@ -60,11 +60,6 @@ public class RulesEngineParameters { */ private int priorityThreshold; - /** - * Parameter to mute loggers. - */ - private boolean silentMode; - /** * Create a new {@link RulesEngineParameters} with default values. */ @@ -74,15 +69,24 @@ public class RulesEngineParameters { /** * Create a new {@link RulesEngineParameters} - * @deprecated Use {@link RulesEngineParameters#RulesEngineParameters(boolean, boolean, boolean, boolean, int, boolean)} instead. + * @deprecated Use {@link RulesEngineParameters#RulesEngineParameters(boolean, boolean, boolean, boolean, int)} instead. * This constructor will be removed in v3.2 */ @Deprecated - public RulesEngineParameters(boolean skipOnFirstAppliedRule, boolean skipOnFirstFailedRule, int priorityThreshold, boolean silentMode) { + public RulesEngineParameters(final boolean skipOnFirstAppliedRule, final boolean skipOnFirstFailedRule, final int priorityThreshold, final boolean silentMode) { this.skipOnFirstAppliedRule = skipOnFirstAppliedRule; this.skipOnFirstFailedRule = skipOnFirstFailedRule; this.priorityThreshold = priorityThreshold; - this.silentMode = silentMode; + } + + /** + * Create a new {@link RulesEngineParameters}. + * @deprecated Use {@link RulesEngineParameters#RulesEngineParameters(boolean, boolean, boolean, boolean, int)} instead. + * This constructor will be removed in v3.2 + */ + @Deprecated + public RulesEngineParameters(final boolean skipOnFirstAppliedRule, final boolean skipOnFirstFailedRule, final boolean skipOnFirstNonTriggeredRule, final boolean skipOnMissingFact, final int priorityThreshold, final boolean silentMode) { + this(skipOnFirstAppliedRule, skipOnFirstFailedRule, skipOnFirstNonTriggeredRule, skipOnMissingFact, priorityThreshold); } /** @@ -93,38 +97,46 @@ public class RulesEngineParameters { * @param skipOnFirstNonTriggeredRule parameter to skip next applicable rules on first non triggered rule. * @param skipOnMissingFact parameter to skip a rule if a declared fact is missing. * @param priorityThreshold threshold after which rules should be skipped. - * @param silentMode parameter to mute all loggers. */ - public RulesEngineParameters(boolean skipOnFirstAppliedRule, boolean skipOnFirstFailedRule, boolean skipOnFirstNonTriggeredRule, boolean skipOnMissingFact, int priorityThreshold, boolean silentMode) { + public RulesEngineParameters(final boolean skipOnFirstAppliedRule, final boolean skipOnFirstFailedRule, final boolean skipOnFirstNonTriggeredRule, final boolean skipOnMissingFact, final int priorityThreshold) { this.skipOnFirstAppliedRule = skipOnFirstAppliedRule; this.skipOnFirstFailedRule = skipOnFirstFailedRule; this.skipOnFirstNonTriggeredRule = skipOnFirstNonTriggeredRule; this.skipOnMissingFact = skipOnMissingFact; this.priorityThreshold = priorityThreshold; - this.silentMode = silentMode; } public int getPriorityThreshold() { return priorityThreshold; } - public void setPriorityThreshold(int priorityThreshold) { - this.priorityThreshold = priorityThreshold; + /** + * @deprecated Silent mode is now log implementation config. Now it uses slf4j facade + * This will be removed in v3.2 + */ + @Deprecated + public boolean isSilentMode() { + return false; } - public boolean isSilentMode() { - return silentMode; + /** + * @deprecated Silent mode is now log implementation config. Now it uses slf4j facade + * This will be removed in v3.2 + */ + @Deprecated + public void setSilentMode(final boolean silentMode) { + } - public void setSilentMode(boolean silentMode) { - this.silentMode = silentMode; + public void setPriorityThreshold(final int priorityThreshold) { + this.priorityThreshold = priorityThreshold; } public boolean isSkipOnFirstAppliedRule() { return skipOnFirstAppliedRule; } - public void setSkipOnFirstAppliedRule(boolean skipOnFirstAppliedRule) { + public void setSkipOnFirstAppliedRule(final boolean skipOnFirstAppliedRule) { this.skipOnFirstAppliedRule = skipOnFirstAppliedRule; } @@ -132,7 +144,7 @@ public class RulesEngineParameters { return skipOnFirstNonTriggeredRule; } - public void setSkipOnFirstNonTriggeredRule(boolean skipOnFirstNonTriggeredRule) { + public void setSkipOnFirstNonTriggeredRule(final boolean skipOnFirstNonTriggeredRule) { this.skipOnFirstNonTriggeredRule = skipOnFirstNonTriggeredRule; } @@ -140,7 +152,7 @@ public class RulesEngineParameters { return skipOnFirstFailedRule; } - public void setSkipOnFirstFailedRule(boolean skipOnFirstFailedRule) { + public void setSkipOnFirstFailedRule(final boolean skipOnFirstFailedRule) { this.skipOnFirstFailedRule = skipOnFirstFailedRule; } @@ -148,7 +160,7 @@ public class RulesEngineParameters { return skipOnMissingFact; } - public void setSkipOnMissingFact(boolean skipOnMissingFact) { + public void setSkipOnMissingFact(final boolean skipOnMissingFact) { this.skipOnMissingFact = skipOnMissingFact; } } diff --git a/easy-rules-core/src/main/java/org/jeasy/rules/core/Utils.java b/easy-rules-core/src/main/java/org/jeasy/rules/core/Utils.java index 50657fa..36b025e 100644 --- a/easy-rules-core/src/main/java/org/jeasy/rules/core/Utils.java +++ b/easy-rules-core/src/main/java/org/jeasy/rules/core/Utils.java @@ -23,55 +23,14 @@ */ package org.jeasy.rules.core; -import java.io.IOException; import java.lang.annotation.Annotation; -import java.util.ArrayList; -import java.util.Enumeration; -import java.util.List; -import java.util.logging.Handler; -import java.util.logging.Level; -import java.util.logging.LogManager; -import java.util.logging.Logger; - -import static java.util.Arrays.asList; final class Utils { - private static final Logger LOGGER = Logger.getLogger(Utils.class.getName()); - - static { - try { - if (System.getProperty("java.util.logging.config.file") == null && - System.getProperty("java.util.logging.config.class") == null) { - LogManager.getLogManager().readConfiguration(Utils.class.getResourceAsStream("/logging.properties")); - } - } catch (IOException e) { - LOGGER.log(Level.WARNING, "Unable to load logging configuration file", e); - } - } - private Utils() { } - static void muteLoggers() { - Enumeration loggerNames = LogManager.getLogManager().getLoggerNames(); - while (loggerNames.hasMoreElements()) { - String loggerName = loggerNames.nextElement(); - if (loggerName.startsWith("org.jeasy.rules")) { - muteLogger(loggerName); - } - } - } - - private static void muteLogger(final String logger) { - Logger.getLogger(logger).setUseParentHandlers(false); - Handler[] handlers = Logger.getLogger(logger).getHandlers(); - for (Handler handler : handlers) { - Logger.getLogger(logger).removeHandler(handler); - } - } - static A findAnnotation(final Class targetAnnotation, final Class annotatedType) { A foundAnnotation = annotatedType.getAnnotation(targetAnnotation); diff --git a/easy-rules-core/src/main/resources/logging.properties b/easy-rules-core/src/main/resources/logging.properties deleted file mode 100644 index 0ce8a2e..0000000 --- a/easy-rules-core/src/main/resources/logging.properties +++ /dev/null @@ -1,4 +0,0 @@ -handlers=java.util.logging.ConsoleHandler -java.util.logging.ConsoleHandler.level=INFO -java.util.logging.ConsoleHandler.formatter=java.util.logging.SimpleFormatter -java.util.logging.SimpleFormatter.format=%1$tF %tT.%1$tL %4$s [%2$s] - %5$s %6$s%n \ No newline at end of file diff --git a/easy-rules-core/src/test/java/org/jeasy/rules/core/DefaultRulesEngineTest.java b/easy-rules-core/src/test/java/org/jeasy/rules/core/DefaultRulesEngineTest.java index 845adca..ec716db 100644 --- a/easy-rules-core/src/test/java/org/jeasy/rules/core/DefaultRulesEngineTest.java +++ b/easy-rules-core/src/test/java/org/jeasy/rules/core/DefaultRulesEngineTest.java @@ -23,22 +23,24 @@ */ package org.jeasy.rules.core; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.Assert.assertEquals; +import static org.mockito.Mockito.inOrder; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.util.Map; import org.assertj.core.api.Assertions; import org.jeasy.rules.annotation.Action; import org.jeasy.rules.annotation.Condition; import org.jeasy.rules.annotation.Priority; -import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.RuleListener; import org.junit.After; import org.junit.Before; import org.junit.Test; -import org.mockito.*; - -import java.util.Map; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.junit.Assert.assertEquals; -import static org.mockito.Mockito.*; +import org.mockito.InOrder; +import org.mockito.Mock; /** * Test class for {@link DefaultRulesEngine}. @@ -56,7 +58,6 @@ public class DefaultRulesEngineTest extends AbstractTest { public void setup() throws Exception { super.setup(); when(rule1.getName()).thenReturn("r"); - when(rule1.getDescription()).thenReturn("d"); when(rule1.getPriority()).thenReturn(1); annotatedRule = new AnnotatedRule(); } diff --git a/easy-rules-core/src/test/java/org/jeasy/rules/core/RulesEngineBuilderTest.java b/easy-rules-core/src/test/java/org/jeasy/rules/core/RulesEngineBuilderTest.java index 23c922b..93a16bc 100644 --- a/easy-rules-core/src/test/java/org/jeasy/rules/core/RulesEngineBuilderTest.java +++ b/easy-rules-core/src/test/java/org/jeasy/rules/core/RulesEngineBuilderTest.java @@ -23,6 +23,8 @@ */ package org.jeasy.rules.core; +import static org.assertj.core.api.Assertions.assertThat; + import org.jeasy.rules.api.RuleListener; import org.jeasy.rules.api.RulesEngine; import org.junit.Test; @@ -30,8 +32,6 @@ import org.junit.runner.RunWith; import org.mockito.Mock; import org.mockito.junit.MockitoJUnitRunner; -import static org.assertj.core.api.Assertions.assertThat; - @RunWith(MockitoJUnitRunner.class) public class RulesEngineBuilderTest { @@ -64,7 +64,6 @@ public class RulesEngineBuilderTest { RulesEngine rulesEngine = RulesEngineBuilder.aNewRulesEngine() .withRuleListener(ruleListener) .withRulePriorityThreshold(expectedThreshold) - .withSilentMode(true) .withSkipOnFirstNonTriggeredRule(true) .withSkipOnFirstAppliedRule(true) .withSkipOnFirstFailedRule(true) @@ -74,9 +73,8 @@ public class RulesEngineBuilderTest { assertThat(rulesEngine).isNotNull(); RulesEngineParameters parameters = rulesEngine.getParameters(); assertThat(parameters.getPriorityThreshold()).isEqualTo(expectedThreshold); - assertThat(parameters.isSilentMode()).isTrue(); assertThat(parameters.isSkipOnFirstAppliedRule()).isTrue(); assertThat(parameters.isSkipOnFirstFailedRule()).isTrue(); assertThat(parameters.isSkipOnFirstNonTriggeredRule()).isTrue(); } -} \ No newline at end of file +} diff --git a/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzzWithEasyRules.java b/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzzWithEasyRules.java index 69d5500..a69356a 100644 --- a/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzzWithEasyRules.java +++ b/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/fizzbuzz/FizzBuzzWithEasyRules.java @@ -23,18 +23,17 @@ */ package org.jeasy.rules.tutorials.fizzbuzz; +import static org.jeasy.rules.core.RulesEngineBuilder.aNewRulesEngine; + import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.Rules; import org.jeasy.rules.api.RulesEngine; -import static org.jeasy.rules.core.RulesEngineBuilder.aNewRulesEngine; - public class FizzBuzzWithEasyRules { public static void main(String[] args) { // create rules engine RulesEngine fizzBuzzEngine = aNewRulesEngine() .withSkipOnFirstAppliedRule(true) - .withSilentMode(true) .build(); // create rules diff --git a/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestFilter.java b/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestFilter.java index 4731ffa..d5ed3ea 100644 --- a/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestFilter.java +++ b/easy-rules-tutorials/src/main/java/org/jeasy/rules/tutorials/web/SuspiciousRequestFilter.java @@ -23,16 +23,20 @@ */ package org.jeasy.rules.tutorials.web; +import static org.jeasy.rules.core.RulesEngineBuilder.aNewRulesEngine; + +import java.io.IOException; +import javax.servlet.Filter; +import javax.servlet.FilterChain; +import javax.servlet.FilterConfig; +import javax.servlet.ServletException; +import javax.servlet.ServletRequest; +import javax.servlet.ServletResponse; +import javax.servlet.annotation.WebFilter; import org.jeasy.rules.api.Facts; import org.jeasy.rules.api.Rules; import org.jeasy.rules.api.RulesEngine; -import javax.servlet.*; -import javax.servlet.annotation.WebFilter; -import java.io.IOException; - -import static org.jeasy.rules.core.RulesEngineBuilder.aNewRulesEngine; - @WebFilter("/*") public class SuspiciousRequestFilter implements Filter { @@ -41,7 +45,7 @@ public class SuspiciousRequestFilter implements Filter { @Override public void init(FilterConfig filterConfig) throws ServletException { - rulesEngine = aNewRulesEngine().withSilentMode(true).build(); + rulesEngine = aNewRulesEngine().build(); rules = new Rules(); rules.register(new SuspiciousRequestRule()); } @@ -58,4 +62,4 @@ public class SuspiciousRequestFilter implements Filter { public void destroy() { } -} \ No newline at end of file +} diff --git a/pom.xml b/pom.xml index f53a608..fc7446d 100644 --- a/pom.xml +++ b/pom.xml @@ -30,6 +30,7 @@ 4.12 2.6.0 2.7.1 + 1.7.25 2.7 4.3.0 2.5.3 @@ -84,6 +85,12 @@ ${project.version} + + org.slf4j + slf4j-api + ${slf4j-api.version} + + junit junit @@ -187,4 +194,4 @@ - \ No newline at end of file +