Package org.apache.shiro.util

Class AntPathMatcher

  • All Implemented Interfaces:
    PatternMatcher
    public class AntPathMatcher
extends 
implements PatternMatcher

    PathMatcher implementation for Ant-style path patterns. Examples are provided below.

    Part of this mapping code has been kindly borrowed from .

    The mapping matches URLs using the following rules:

    • ? matches one character
    • * matches zero or more characters
    • ** matches zero or more 'directories' in a path

    Some examples:

    • com/t?st.jsp - matches com/test.jsp but also com/tast.jsp or com/txst.jsp
    • com/*.jsp - matches all .jsp files in the com directory
    • com/**/test.jsp - matches all test.jsp files underneath the com path
    • org/apache/shiro/**/*.jsp - matches all .jsp files underneath the org/apache/shiro path
    • org/**/servlet/bla.jsp - matches org/apache/shiro/servlet/bla.jsp but also org/apache/shiro/testing/servlet/bla.jsp and org/servlet/bla.jsp

    N.B.: This class was borrowed (with much appreciation) from the with modifications. We didn't want to reinvent the wheel of great work they've done, but also didn't want to force every Shiro user to depend on Spring

    As per the Apache 2.0 license, the original copyright notice and all author and copyright information have remained in tact.

    Since:
    16.07.2003

    • Field Summary

      Fields 
      Modifier and Type Field Description
      static DEFAULT_PATH_SEPARATOR
      Default path separator: "/"

    • Constructor Summary

      Constructors 
      Constructor Description
      AntPathMatcher()  

    • Method Summary

      All Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      protected boolean  pattern,  path, boolean fullMatch)
      Actually match the given path against the given pattern.
       pattern,  path)
      Given a pattern and a full path, determine the pattern-mapped part.
      boolean  path)
      Checks if path is a pattern (i.e.
      boolean  pattern,  path)  
      boolean  pattern,  source)
      Returns true if the given source matches the specified pattern, false otherwise.
      boolean  pattern,  path)  
      void  pathSeparator)
      Set the path separator to use for pattern parsing.

      • Methods inherited from class java.lang.

        , , , , , , , , , ,

    • Field Detail

      • DEFAULT_PATH_SEPARATOR

        public static final  DEFAULT_PATH_SEPARATOR
        Default path separator: "/"
        See Also:
        Constant Field Values

    • Constructor Detail

      • AntPathMatcher

        public AntPathMatcher()

    • Method Detail

      • setPathSeparator

        public void setPathSeparator​( pathSeparator)
        Set the path separator to use for pattern parsing. Default is "/", as in Ant.

      • isPattern

        public boolean isPattern​( path)
        Checks if path is a pattern (i.e. contains a '*', or '?'). For example the /foo/** would return true, while /bar/ would return false.
        Parameters:
        path - the string to check
        Returns:
        this method returns true if path contains a '*' or '?', otherwise, false

      • matches

        public boolean matches​( pattern,
                        source)
        Description copied from interface: PatternMatcher
        Returns true if the given source matches the specified pattern, false otherwise.
        Specified by:
        matches in interface PatternMatcher
        Parameters:
        pattern - the pattern to match against
        source - the source to match
        Returns:
        true if the given source matches the specified pattern, false otherwise.

      • match

        public boolean match​( pattern,
                      path)

      • matchStart

        public boolean matchStart​( pattern,
                           path)

      • doMatch

        protected boolean doMatch​( pattern,
                           path,
                          boolean fullMatch)
        Actually match the given path against the given pattern.
        Parameters:
        pattern - the pattern to match against
        path - the path String to test
        fullMatch - whether a full pattern match is required (else a pattern match as far as the given base path goes is sufficient)
        Returns:
        true if the supplied path matched, false if it didn't

      • extractPathWithinPattern

        public  extractPathWithinPattern​( pattern,
                                        path)
        Given a pattern and a full path, determine the pattern-mapped part.

        For example:

        • '/docs/cvs/commit.html' and '/docs/cvs/commit.html -> ''
        • '/docs/*' and '/docs/cvs/commit -> 'cvs/commit'
        • '/docs/cvs/*.html' and '/docs/cvs/commit.html -> 'commit.html'
        • '/docs/**' and '/docs/cvs/commit -> 'cvs/commit'
        • '/docs/**\/*.html' and '/docs/cvs/commit.html -> 'cvs/commit.html'
        • '/*.html' and '/docs/cvs/commit.html -> 'docs/cvs/commit.html'
        • '*.html' and '/docs/cvs/commit.html -> '/docs/cvs/commit.html'
        • '*' and '/docs/cvs/commit.html -> '/docs/cvs/commit.html'

        Assumes that match(java.lang.String, java.lang.String) returns true for 'pattern' and 'path', but does not enforce this.