diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/AbstractDependencyFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/AbstractDependencyFilter.java
index b5e4393..0535309 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/AbstractDependencyFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/AbstractDependencyFilter.java
@@ -19,6 +19,8 @@
  * under the License.
  */
 
+import org.apache.maven.model.Dependency;
+
 import java.util.HashSet;
 import java.util.Locale;
 import java.util.Set;
@@ -26,6 +28,82 @@
 
 abstract class AbstractDependencyFilter implements DependencyFilter
 {
+
+    protected final String includeIds;
+    protected final String excludeIds;
+
+    AbstractDependencyFilter( String includeIds, String excludeIds )
+    {
+        this.includeIds = includeIds == null ? "" : includeIds;
+        this.excludeIds = excludeIds == null ? "" : excludeIds;
+    }
+
+
+    @Override
+    public Set<Dependency> filter( Set<Dependency> dependencies )
+    {
+        Set<Dependency> filtered = new HashSet<>( dependencies );
+
+        filtered = filterincludeIds( filtered );
+        filtered = filterexcludeIds( filtered );
+
+        return filtered;
+    }
+
+    private Set<Dependency> filterexcludeIds( Set<Dependency> dependencies )
+    {
+        if ( excludeIds.trim().isEmpty() )
+        {
+            return dependencies;
+        }
+
+        final Set<String> excludedIds = splitExcludeIds( excludeIds );
+
+        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
+        for ( Dependency dependency : dependencies )
+        {
+            if ( excludedIds.contains( getContainsProperty( dependency ) ) )
+            {
+                continue;
+            }
+
+            filtered.add( dependency );
+        }
+
+        return filtered;
+    }
+
+    private Set<Dependency> filterincludeIds( Set<Dependency> dependencies )
+    {
+        if ( includeIds.trim().isEmpty() )
+        {
+            return dependencies;
+        }
+
+        Set<String> includedIds = splitIncludeIds( includeIds );
+
+        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
+        for ( Dependency dependency : dependencies )
+        {
+            if ( includedIds.contains( getContainsProperty( dependency ) ) )
+            {
+                filtered.add( dependency );
+            }
+        }
+
+        return filtered;
+    }
+
+    protected Set<String> splitExcludeIds( String excludeIds )
+    {
+        return splitValues( excludeIds );
+    }
+
+    protected Set<String> splitIncludeIds( String includeIds )
+    {
+        return splitValues( includeIds );
+    }
+
     protected Set<String> splitValues( String csvValueList )
     {
         final String[] values = csvValueList.split( "," );
@@ -47,4 +125,6 @@
 
         return excludeScope;
     }
+
+    protected abstract String getContainsProperty( Dependency dependency );
 }
diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/ArtifactIdFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/ArtifactIdFilter.java
index c06c7c6..59423d4 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/ArtifactIdFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/ArtifactIdFilter.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.maven.model.Dependency;
 
 /**
@@ -29,70 +26,14 @@
  */
 public class ArtifactIdFilter extends AbstractDependencyFilter
 {
-    private final String includeArtifactIds;
-
-    private final String excludeArtifactIds;
-
     public ArtifactIdFilter( String includeArtifactIds, String excludeArtifactIds )
     {
-        this.includeArtifactIds = includeArtifactIds == null ? "" : includeArtifactIds;
-        this.excludeArtifactIds = excludeArtifactIds == null ? "" : excludeArtifactIds;
+        super( includeArtifactIds, excludeArtifactIds );
     }
 
     @Override
-    public Set<Dependency> filter( Set<Dependency> dependencies )
+    protected String getContainsProperty( Dependency dependency )
     {
-        Set<Dependency> filtered = new HashSet<>( dependencies );
-
-        filtered = filterIncludeArtifactIds( filtered );
-        filtered = filterExcludeArtifactIds( filtered );
-
-        return filtered;
+        return dependency.getArtifactId();
     }
-
-    private Set<Dependency> filterExcludeArtifactIds( Set<Dependency> dependencies )
-    {
-        if ( excludeArtifactIds.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        final Set<String> excludedArtifactIds = splitValues( excludeArtifactIds );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( excludedArtifactIds.contains( dependency.getArtifactId() ) )
-            {
-                continue;
-            }
-
-            filtered.add( dependency );
-        }
-
-        return filtered;
-    }
-
-    private Set<Dependency> filterIncludeArtifactIds( Set<Dependency> dependencies )
-    {
-        if ( includeArtifactIds.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        Set<String> includedArtifactIds = splitValues( includeArtifactIds );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( includedArtifactIds.contains( dependency.getArtifactId() ) )
-            {
-                filtered.add( dependency );
-            }
-        }
-
-        return filtered;
-    }
-
-
 }
diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/ClassifierFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/ClassifierFilter.java
index 7e1defa..4859be0 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/ClassifierFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/ClassifierFilter.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.maven.model.Dependency;
 
 /**
@@ -29,70 +26,16 @@
  */
 public class ClassifierFilter extends AbstractDependencyFilter
 {
-    private final String includeClassifiers;
-
-    private final String excludeClassifiers;
 
     public ClassifierFilter( String includeClassifiers, String excludeClassifiers )
     {
-        this.includeClassifiers = includeClassifiers == null ? "" : includeClassifiers;
-        this.excludeClassifiers = excludeClassifiers == null ? "" : excludeClassifiers;
+        super( includeClassifiers, excludeClassifiers );
     }
 
     @Override
-    public Set<Dependency> filter( Set<Dependency> dependencies )
+    protected String getContainsProperty( Dependency dependency )
     {
-        Set<Dependency> filtered = new HashSet<>( dependencies );
-
-        filtered = filterIncludeClassifier( filtered );
-        filtered = filterExcludeClassifier( filtered );
-
-        return filtered;
+        return dependency.getClassifier();
     }
 
-    private Set<Dependency> filterExcludeClassifier( Set<Dependency> dependencies )
-    {
-        if ( excludeClassifiers.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        final Set<String> excludedClassifiers = splitValues( excludeClassifiers );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( excludedClassifiers.contains( dependency.getClassifier() ) )
-            {
-                continue;
-            }
-
-            filtered.add( dependency );
-        }
-
-        return filtered;
-    }
-
-    private Set<Dependency> filterIncludeClassifier( Set<Dependency> dependencies )
-    {
-        if ( includeClassifiers.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        Set<String> includedClassifiers = splitValues( includeClassifiers );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( includedClassifiers.contains( dependency.getClassifier() ) )
-            {
-                filtered.add( dependency );
-            }
-        }
-
-        return filtered;
-    }
-
-
 }
diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/GroupIdFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/GroupIdFilter.java
index 5ca5e5b..395fd97 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/GroupIdFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/GroupIdFilter.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.maven.model.Dependency;
 
 /**
@@ -29,70 +26,14 @@
  */
 public class GroupIdFilter extends AbstractDependencyFilter
 {
-    private final String includeGroupIds;
-
-    private final String excludeGroupIds;
-
     public GroupIdFilter( String includeGroupIds, String excludeGroupIds )
     {
-        this.includeGroupIds = includeGroupIds == null ? "" : includeGroupIds;
-        this.excludeGroupIds = excludeGroupIds == null ? "" : excludeGroupIds;
+        super( includeGroupIds, excludeGroupIds );
     }
 
     @Override
-    public Set<Dependency> filter( Set<Dependency> dependencies )
+    protected String getContainsProperty( Dependency dependency )
     {
-        Set<Dependency> filtered = new HashSet<>( dependencies );
-
-        filtered = filterIncludeGroupIds( filtered );
-        filtered = filterExcludeGroupIds( filtered );
-
-        return filtered;
+        return dependency.getGroupId();
     }
-
-    private Set<Dependency> filterExcludeGroupIds( Set<Dependency> dependencies )
-    {
-        if ( excludeGroupIds.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        final Set<String> excludedGroupIds = splitValues( excludeGroupIds );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( excludedGroupIds.contains( dependency.getGroupId() ) )
-            {
-                continue;
-            }
-
-            filtered.add( dependency );
-        }
-
-        return filtered;
-    }
-
-    private Set<Dependency> filterIncludeGroupIds( Set<Dependency> dependencies )
-    {
-        if ( includeGroupIds.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        Set<String> includedGroupIds = splitValues( includeGroupIds );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( includedGroupIds.contains( dependency.getGroupId() ) )
-            {
-                filtered.add( dependency );
-            }
-        }
-
-        return filtered;
-    }
-
-
 }
diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/ScopeFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/ScopeFilter.java
index 8a47a1d..47f1f1a 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/ScopeFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/ScopeFilter.java
@@ -19,153 +19,104 @@
  * under the License.
  */
 
-import static java.util.Arrays.asList;
-import static java.util.Collections.singletonList;
+import org.apache.maven.artifact.Artifact;
+import org.apache.maven.model.Dependency;
 
 import java.util.HashSet;
 import java.util.Set;
 
-import org.apache.maven.artifact.Artifact;
-import org.apache.maven.model.Dependency;
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonList;
 
 /**
  * Filters dependencies by scope.
  */
 public class ScopeFilter extends AbstractDependencyFilter
 {
-    private final String includeScope;
-
-    private final String excludeScope;
-
     public ScopeFilter( String includeScope, String excludeScope )
     {
-        this.includeScope = includeScope == null ? "" : includeScope;
-        this.excludeScope = excludeScope == null ? "" : excludeScope;
+        super( includeScope, excludeScope );
     }
 
     @Override
-    public Set<Dependency> filter( Set<Dependency> dependencies )
+    protected String getContainsProperty( Dependency dependency )
     {
-        Set<Dependency> filtered = new HashSet<>( dependencies );
-
-        filtered = filterIncludeScope( filtered );
-        filtered = filterExcludeScope( filtered );
-
-        return filtered;
+        return dependency.getScope();
     }
 
-    private Set<Dependency> filterExcludeScope( Set<Dependency> dependencies )
+    /*
+     * runtime exclude scope excludes runtime and compile dependencies,
+     * compile exclude scope excludes compile, provided, and system dependencies,
+     * test exclude scope excludes all dependencies, then not really a legitimate option: it will
+     * fail, you probably meant to configure includeScope = compile
+     * provided exclude scope just excludes provided dependencies,
+     * system exclude scope just excludes system dependencies.
+     * @param scope to be excluded
+     * @return Set with excluded scopes
+     */
+    @Override
+    protected Set<String> splitExcludeIds( String scope )
     {
-        if ( excludeScope.trim().isEmpty() )
+        switch ( scope )
         {
-            return dependencies;
-        }
-
-        final Set<String> excludedScopes = toResolvedScopes( excludeScope, true );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( excludedScopes.contains( dependency.getScope() ) )
-            {
-                continue;
-            }
-
-            filtered.add( dependency );
-        }
-
-        return filtered;
-    }
-
-    private Set<Dependency> filterIncludeScope( Set<Dependency> dependencies )
-    {
-        if ( includeScope.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        Set<String> includedScopes = toResolvedScopes( includeScope, false );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( includedScopes.contains( dependency.getScope() ) )
-            {
-                filtered.add( dependency );
-            }
-        }
-
-        return filtered;
-    }
-
-    private Set<String> toResolvedScopes( String scope, boolean isExcludeScope )
-    {
-        if ( isExcludeScope )
-        {
-            /*
-             * runtime exclude scope excludes runtime and compile dependencies,
-             * compile exclude scope excludes compile, provided, and system dependencies,
-             * test exclude scope excludes all dependencies, then not really a legitimate option: it will
-             * fail, you probably meant to configure includeScope = compile
-             * provided exclude scope just excludes provided dependencies,
-             * system exclude scope just excludes system dependencies.
-             */
-            switch ( scope )
-            {
-                case Artifact.SCOPE_RUNTIME:
-                    return new HashSet<>( asList(
-                            Artifact.SCOPE_RUNTIME,
-                            Artifact.SCOPE_COMPILE ) );
-                case Artifact.SCOPE_COMPILE:
-                    return new HashSet<>( asList(
-                            Artifact.SCOPE_COMPILE,
-                            Artifact.SCOPE_PROVIDED,
-                            Artifact.SCOPE_SYSTEM ) );
-                case Artifact.SCOPE_TEST:
-                    throw new IllegalArgumentException( "invalid exclude scope: test. Did you mean compile?" );
-                case Artifact.SCOPE_PROVIDED:
-                    return new HashSet<>( singletonList( Artifact.SCOPE_PROVIDED ) );
-                case Artifact.SCOPE_SYSTEM:
-                    return new HashSet<>( singletonList( Artifact.SCOPE_SYSTEM ) );
-                default:
-                    throw new IllegalArgumentException( "Invalid Scope: " + scope );
-            }
-        }
-        else
-        {
-            /*
-             * runtime include scope gives runtime and compile dependencies,
-             * compile include scope gives compile, provided, and system dependencies,
-             * test include scope gives all dependencies (equivalent to default),
-             * provided include scope just gives provided dependencies,
-             * system include scope just gives system dependencies.
-             */
-            switch ( scope )
-            {
-                case Artifact.SCOPE_RUNTIME:
-                    return new HashSet<>( asList(
-                            Artifact.SCOPE_RUNTIME,
-                            Artifact.SCOPE_COMPILE ) );
-                case Artifact.SCOPE_COMPILE:
-                    return new HashSet<>( asList(
-                            Artifact.SCOPE_COMPILE,
-                            Artifact.SCOPE_PROVIDED,
-                            Artifact.SCOPE_SYSTEM ) );
-                case Artifact.SCOPE_TEST:
-                    return new HashSet<>( asList(
-                            Artifact.SCOPE_COMPILE,
-                            Artifact.SCOPE_PROVIDED,
-                            Artifact.SCOPE_SYSTEM,
-                            Artifact.SCOPE_TEST,
-                            Artifact.SCOPE_RUNTIME ) );
-                case Artifact.SCOPE_PROVIDED:
-                    return new HashSet<>( singletonList( Artifact.SCOPE_PROVIDED ) );
-                case Artifact.SCOPE_SYSTEM:
-                    return new HashSet<>( singletonList( Artifact.SCOPE_SYSTEM ) );
-                default:
-                    throw new IllegalArgumentException( "Invalid Scope: " + scope );
-            }
+            case Artifact.SCOPE_RUNTIME:
+                return new HashSet<>( asList(
+                        Artifact.SCOPE_RUNTIME,
+                        Artifact.SCOPE_COMPILE ) );
+            case Artifact.SCOPE_COMPILE:
+                return new HashSet<>( asList(
+                        Artifact.SCOPE_COMPILE,
+                        Artifact.SCOPE_PROVIDED,
+                        Artifact.SCOPE_SYSTEM ) );
+            case Artifact.SCOPE_TEST:
+                throw new IllegalArgumentException( "invalid exclude scope: test. Did you mean compile?" );
+            case Artifact.SCOPE_PROVIDED:
+                return new HashSet<>( singletonList( Artifact.SCOPE_PROVIDED ) );
+            case Artifact.SCOPE_SYSTEM:
+                return new HashSet<>( singletonList( Artifact.SCOPE_SYSTEM ) );
+            default:
+                throw new IllegalArgumentException( "Invalid Scope: " + scope );
         }
     }
 
+    /**
+     * runtime include scope gives runtime and compile dependencies,
+     * compile include scope gives compile, provided, and system dependencies,
+     * test include scope gives all dependencies (equivalent to default),
+     * provided include scope just gives provided dependencies,
+     * system include scope just gives system dependencies.
+     *
+     * @param scope to be included
+     * @return set with included scopes
+     */
+    @Override
+    protected Set<String> splitIncludeIds( String scope )
+    {
+        switch ( scope )
+        {
+            case Artifact.SCOPE_RUNTIME:
+                return new HashSet<>( asList(
+                        Artifact.SCOPE_RUNTIME,
+                        Artifact.SCOPE_COMPILE ) );
+            case Artifact.SCOPE_COMPILE:
+                return new HashSet<>( asList(
+                        Artifact.SCOPE_COMPILE,
+                        Artifact.SCOPE_PROVIDED,
+                        Artifact.SCOPE_SYSTEM ) );
+            case Artifact.SCOPE_TEST:
+                return new HashSet<>( asList(
+                        Artifact.SCOPE_COMPILE,
+                        Artifact.SCOPE_PROVIDED,
+                        Artifact.SCOPE_SYSTEM,
+                        Artifact.SCOPE_TEST,
+                        Artifact.SCOPE_RUNTIME ) );
+            case Artifact.SCOPE_PROVIDED:
+                return new HashSet<>( singletonList( Artifact.SCOPE_PROVIDED ) );
+            case Artifact.SCOPE_SYSTEM:
+                return new HashSet<>( singletonList( Artifact.SCOPE_SYSTEM ) );
+            default:
+                throw new IllegalArgumentException( "Invalid Scope: " + scope );
+        }
+
+    }
 }
diff --git a/src/main/java/org/apache/maven/plugins/dependency/filters/TypeFilter.java b/src/main/java/org/apache/maven/plugins/dependency/filters/TypeFilter.java
index 72d38b9..72079e9 100644
--- a/src/main/java/org/apache/maven/plugins/dependency/filters/TypeFilter.java
+++ b/src/main/java/org/apache/maven/plugins/dependency/filters/TypeFilter.java
@@ -19,9 +19,6 @@
  * under the License.
  */
 
-import java.util.HashSet;
-import java.util.Set;
-
 import org.apache.maven.model.Dependency;
 
 /**
@@ -29,70 +26,14 @@
  */
 public class TypeFilter extends AbstractDependencyFilter
 {
-    private final String includeTypes;
-
-    private final String excludeTypes;
-
     public TypeFilter( String includeTypes, String excludeTypes )
     {
-        this.includeTypes = includeTypes == null ? "" : includeTypes;
-        this.excludeTypes = excludeTypes == null ? "" : excludeTypes;
+        super( includeTypes, excludeTypes );
     }
 
     @Override
-    public Set<Dependency> filter( Set<Dependency> dependencies )
+    protected String getContainsProperty( Dependency dependency )
     {
-        Set<Dependency> filtered = new HashSet<>( dependencies );
-
-        filtered = filterIncludeType( filtered );
-        filtered = filterExcludeType( filtered );
-
-        return filtered;
+        return dependency.getType();
     }
-
-    private Set<Dependency> filterExcludeType( Set<Dependency> dependencies )
-    {
-        if ( excludeTypes.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        final Set<String> excludedTypes = splitValues( excludeTypes );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( excludedTypes.contains( dependency.getType() ) )
-            {
-                continue;
-            }
-
-            filtered.add( dependency );
-        }
-
-        return filtered;
-    }
-
-    private Set<Dependency> filterIncludeType( Set<Dependency> dependencies )
-    {
-        if ( includeTypes.trim().isEmpty() )
-        {
-            return dependencies;
-        }
-
-        Set<String> includedTypes = splitValues( includeTypes );
-
-        Set<Dependency> filtered = new HashSet<>( dependencies.size() );
-        for ( Dependency dependency : dependencies )
-        {
-            if ( includedTypes.contains( dependency.getType() ) )
-            {
-                filtered.add( dependency );
-            }
-        }
-
-        return filtered;
-    }
-
-
 }