public Registration(WebFilter annotation) {
    urlPatterns = new ArrayList<>();
    dispatcherTypes = new ArrayList<>();

    EnumSet<dispatcherType> dispatchers = EnumSet.noneOf(dispatcherType.class);
    dispatchers.addAll(Arrays.asList(annotation.dispatcherTypes()));

    if (annotation.value().length > 0) {
        addMappingForUrlPatterns(dispatchers,true,annotation.value());
    }

    if (annotation.urlPatterns().length > 0) {
        addMappingForUrlPatterns(dispatchers,annotation.urlPatterns());
    }

    asyncSupported = annotation.asyncSupported();
}

public MappedFilter toMappedFilter(Filter filter,int order) {

        WebFilter wfAnnotation = filter.getClass().getAnnotation(WebFilter.class);

        if (wfAnnotation == null) {
            throw new IllegalArgumentException(
                    "Filter contains no @WebFilter annotation and can not be mapped directly. Wrap it in a MappedFilter instead.");
        }

        String name = wfAnnotation.filterName() != null && wfAnnotation.filterName().length() > 0
                ? wfAnnotation.filterName() : null;
        Set<String> urlPatterns = new HashSet<>(asList(wfAnnotation.urlPatterns()));

        Map<String,String> initParams = new HashMap<>();

        WebInitParam[] paramsArray = wfAnnotation.initParams();
        if (paramsArray != null) {
            asList(paramsArray).forEach(p -> initParams.put(p.name(),p.value()));
        }

        return new MappedFilter(filter,urlPatterns,name,initParams,order);
    }

private void registerJeeComponents(ConfigurableListablebeanfactory beanfactory,ClassLoader cl,Set<BeanDeFinition> candiates) {

    for (BeanDeFinition bd : candiates) {

        try {
            Class<?> beanClass = ClassUtils.forName(bd.getBeanClassName(),cl);
            WebServlet webServlet = beanClass.getDeclaredAnnotation(WebServlet.class);
            WebFilter webFilter = beanClass.getDeclaredAnnotation(WebFilter.class);
            WebListener webListener = beanClass.getDeclaredAnnotation(WebListener.class);

            DefaultListablebeanfactory targetbeanfactory = (DefaultListablebeanfactory) beanfactory;

            if (webServlet != null) {
                createAndRegisterServletBean(targetbeanfactory,bd,beanClass,webServlet);
            } else if (webFilter != null) {
                createAndRegisterServletFilterBean(targetbeanfactory,webFilter);
            } else if (webListener != null) {
                createAndRegisterWebListenerBean(targetbeanfactory,webListener);
            }

        } catch (ClassNotFoundException e) {
            e.printstacktrace();
        }
    }
}

/**
 * Method invoked for tracking filters that are registered via the Osgi service registry
 *
 * @param filter The filter to add
 * @return The name of the filter,if added
 */
private String addFilter(Filter filter) {
    Class<?> clz = filter.getClass();
    WebFilter ann = clz.getAnnotation(WebFilter.class);
    if (ann == null) {
        return null;
    }
    String name = ann.filterName();
    DynamicFRegistration reg = addFilter(name,filter);
    if (reg == null) {
        return null;
    }
    reg.addMappingForUrlPatterns(EnumSet.allOf(dispatcherType.class),false,ann.urlPatterns());
    reg.addMappingForServletNames(EnumSet.allOf(dispatcherType.class),ann.servletNames());
    doParameters(reg,ann.initParams());
    return name;
}

@Override
public void install(final Environment environment,final Filter instance) {
    final Class<? extends Filter> extType = FeatureUtils.getInstanceClass(instance);
    final WebFilter annotation = FeatureUtils.getAnnotation(extType,WebFilter.class);
    final String[] servlets = annotation.servletNames();
    final String[] patterns = annotation.urlPatterns().length > 0 ? annotation.urlPatterns() : annotation.value();
    Preconditions.checkArgument(servlets.length > 0 || patterns.length > 0,"Filter %s not specified servlet or pattern for mapping",extType.getName());
    Preconditions.checkArgument(servlets.length == 0 || patterns.length == 0,"Filter %s specifies both servlets and patters,when only one allowed",extType.getName());
    final boolean servletMapping = servlets.length > 0;
    final AdminContext context = FeatureUtils.getAnnotation(extType,AdminContext.class);
    final String name = WebUtils.getFilterName(annotation,extType);
    reporter.line("%-15s %-5s %-2s (%s)   %s",Joiner.on(",").join(servletMapping ? servlets : patterns),WebUtils.getAsyncmarker(annotation),WebUtils.getContextMarkers(context),extType.getName(),name);

    if (WebUtils.isForMain(context)) {
        configure(environment.servlets(),instance,annotation);
    }
    if (WebUtils.isForAdmin(context)) {
        configure(environment.admin(),annotation);
    }
}

private void configure(final ServletEnvironment environment,final Filter filter,final String name,final WebFilter annotation) {
    final FilterRegistration.Dynamic mapping = environment.addFilter(name,filter);
    final EnumSet<dispatcherType> dispatcherTypes = EnumSet.copyOf(Arrays.asList(annotation.dispatcherTypes()));
    if (annotation.servletNames().length > 0) {
        mapping.addMappingForServletNames(dispatcherTypes,annotation.servletNames());
    } else {
        final String[] urlPatterns = annotation.urlPatterns().length > 0
                ? annotation.urlPatterns() : annotation.value();
        mapping.addMappingForUrlPatterns(dispatcherTypes,urlPatterns);
    }
    if (annotation.initParams().length > 0) {
        for (WebInitParam param : annotation.initParams()) {
            mapping.setinitParameter(param.name(),param.value());
        }
    }
    mapping.setAsyncSupported(annotation.asyncSupported());
}

private String readAnnotatedFilterName() {
    if (isAnnotated()) {
        WebFilter regAnnotation = filter.getClass().getAnnotation(WebFilter.class);
        if (!"".equals(regAnnotation.filterName().trim())) {
            return regAnnotation.filterName();
        } else {
            return filter.getClass().getName();
        }
    } else {
        return null;
    }
}

private Map<String,String> readAnnotatedInitParams() {
    Map<String,String> initParams = new HashMap<>();
    if (isAnnotated()) {
        WebFilter regAnnotation = filter.getClass().getAnnotation(WebFilter.class);
        for (WebInitParam param : regAnnotation.initParams()) {
            initParams.put(param.name(),param.value());
        }
    }

    return initParams;
}

private WebFilter getAnnotation() {
    if (isAnnotated()) {
        return filter.getClass().getAnnotation(WebFilter.class);
    } else {
        return null;
    }
}

private void createAndRegisterServletFilterBean(DefaultListablebeanfactory beanfactory,BeanDeFinition bd,Class<?> beanClass,WebFilter webFilter) {

    BeanDeFinitionBuilder builder = BeanDeFinitionBuilder.rootBeanDeFinition(FilterRegistrationBean.class);
    builder.addPropertyValue("filter",bd);
    builder.addPropertyValue("urlPatterns",new LinkedHashSet<>(Arrays.asList(webFilter.urlPatterns())));

    String beanName = webFilter.filterName().isEmpty() ? StringUtils.uncapitalize(beanClass.getSimpleName())
            : webFilter.filterName();

    beanfactory.registerBeanDeFinition(beanName,builder.getBeanDeFinition());
}

private void processFilters() {
    Consumer<Class<? extends Filter>> c = filter -> {
        WebFilter webFilter = ClassUtils.getAnnotation(filter,WebFilter.class);
        if(webFilter != null) {
            FilterDescriptor filterDescriptor = new FilterDescriptor(webFilter.filterName(),webFilter.value(),mapUrls(webFilter.urlPatterns()),webFilter.dispatcherTypes(),webFilter.initParams(),webFilter.asyncSupported(),webFilter.servletNames(),filter);
            webServer.addFilter(filterDescriptor);
        }
    };
    extension.processFilters(c);
}

/**
 * Sets up filters that are annotated with the {@link WebFilter} annotation.
 * Every class in the classpath is searched for the annotation.
 */
@SuppressWarnings("unchecked")
private void bindAnnotatedFilters() {

    String appsPackages = null;
    if (System.getProperties().containsKey(IO_JOYNR_APPS_PACKAGES)) {
        logger.info("Using property {} from system properties",IO_JOYNR_APPS_PACKAGES);
        appsPackages = System.getProperty(IO_JOYNR_APPS_PACKAGES);
    } else {
        Properties servletProperties = PropertyLoader.loadProperties("servlet.properties");
        if (servletProperties.containsKey(IO_JOYNR_APPS_PACKAGES)) {
            appsPackages = servletProperties.getProperty(IO_JOYNR_APPS_PACKAGES);
        }
    }

    if (appsPackages != null) {
        String[] packageNames = appsPackages.split(";");
        logger.info("Searching packages for @WebFilter annotation: {}",Arrays.toString(packageNames));

        PackageNamesScanner scanner = new PackageNamesScanner(packageNames);
        AnnotationScannerListener sl = new AnnotationScannerListener(WebFilter.class);
        scanner.scan(sl);

        for (Class<?> webFilterannotatedClass : sl.getAnnotatedClasses()) {

            if (Filter.class.isAssignableFrom(webFilterannotatedClass)) {
                bind(webFilterannotatedClass).in(Singleton.class);
                filter("/*").through((Class<? extends Filter>) webFilterannotatedClass);
                logger.info("Adding filter {} for '/*'",webFilterannotatedClass.getName());
            }

        }
    }
}

WebFilterHandler() {
    super(WebFilter.class);
}

public boolean isAnnotated() {
    return filter.getClass().isAnnotationPresent(WebFilter.class);
}

WebFilterHandler() {
    super(WebFilter.class);
}

WebFilterHandler() {
    super(WebFilter.class);
}

WebFilterHandler() {
    super(WebFilter.class);
}

@Override
public boolean matches(final Class<?> type) {
    return FeatureUtils.is(type,Filter.class)
            && FeatureUtils.hasAnnotation(type,WebFilter.class);
}

public UndertowComponent addFilter(WebFilter webFilter,Class<? extends Filter> clazz) {
    filters.put(webFilter,clazz);
    return this;
}

public void findFilters(@Observes @WithAnnotations({WebFilter.class})
                                  ProcessAnnotatedType<? extends Filter> pat) {
    filters.add(pat.getAnnotatedType().getJavaClass());
}

/**
 * When filter name not set in annotation,name generates as: . (dot) at the beginning to indicate
 * generated name,followed by lower-cased class name. If class ends with "filter" then it will be cut off.
 * For example,for class "MyCoolFilter" generated name will be ".mycool".
 *
 * @param filter filter annotation
 * @param type   filter type
 * @return filter name or generated name if name not provided
 */
public static String getFilterName(final WebFilter filter,final Class<? extends Filter> type) {
    final String name = Strings.emptyToNull(filter.filterName());
    return name != null ? name : generateName(type,"filter");
}

/**
 * @param annotation filter registration annotation
 * @return "async" string if filter support async and empty string otherwise
 */
public static String getAsyncmarker(final WebFilter annotation) {
    return getAsyncmarker(annotation.asyncSupported());
}

public Object findFilterId(AnnotatedClass paramAnnotatedClass)
{
  JsonFilter localJsonFilter = (JsonFilter)paramAnnotatedClass.getAnnotation(JsonFilter.class);
  if (localJsonFilter != null)
  {
    String str = localJsonFilter.value();
    if (str.length() > 0)
      return str;
  }
  return null;
}

public static String getJsonFilterannotationValue(Class clazz) {
  JsonFilter jsonFilterannotation = (JsonFilter) clazz.getAnnotation(JsonFilter.class);
  if (jsonFilterannotation != null) {
    return jsonFilterannotation.value();
  }

  return null;
}

@Nullable
public static ElementFilter getReferenceFilter(PsiElement position) {
  // Completion after extends in interface,type parameter and implements in class
  final PsiClass containingClass = PsiTreeUtil.getParentOfType(position,PsiClass.class,false,PsiCodeBlock.class,PsiMethod.class,PsiExpressionList.class,PsiVariable.class,PsiAnnotation.class);
  if (containingClass != null && psiElement().afterLeaf(PsiKeyword.EXTENDS,PsiKeyword.IMPLEMENTS,","&").accepts(position)) {
    return new AndFilter(ElementClassFilter.CLASS,new NotFilter(new AssignableFromContextFilter()));
  }

  if (ANNOTATION_NAME.accepts(position)) {
    return new AnnotationTypeFilter();
  }

  if (JavaKeywordCompletion.DECLaraTION_START.getValue().accepts(position) ||
      JavaKeywordCompletion.isInsideParameterList(position) ||
      isInsideAnnotationName(position)) {
    return new OrFilter(ElementClassFilter.CLASS,ElementClassFilter.PACKAGE_FILTER);
  }

  if (psiElement().afterLeaf(PsiKeyword.INSTANCEOF).accepts(position)) {
    return new ElementExtractorFilter(ElementClassFilter.CLASS);
  }

  if (JavaKeywordCompletion.VARIABLE_AFTER_FINAL.accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (isCatchFinallyPosition(position) ||
      JavaKeywordCompletion.START_SWITCH.accepts(position) ||
      JavaKeywordCompletion.isinstanceofPlace(position) ||
      JavaKeywordCompletion.isAfterPrimitiveOrArrayType(position)) {
    return null;
  }

  if (JavaKeywordCompletion.START_FOR.accepts(position)) {
    return new OrFilter(ElementClassFilter.CLASS,ElementClassFilter.VARIABLE);
  }

  if (JavaSmartCompletionContributor.AFTER_NEW.accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (psiElement().inside(PsiReferenceParameterList.class).accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (psiElement().inside(PsiAnnotationParameterList.class).accepts(position)) {
    return createAnnotationFilter(position);
  }

  PsiVariable var = PsiTreeUtil.getParentOfType(position,PsiClass.class);
  if (var != null && PsiTreeUtil.isAncestor(var.getinitializer(),position,false)) {
    return new ExcludeDeclaredFilter(new ClassFilter(PsiVariable.class));
  }

  if (SWITCH_LABEL.accepts(position)) {
    return new ClassFilter(PsiField.class) {
      @Override
      public boolean isAcceptable(Object element,PsiElement context) {
        return element instanceof PsiEnumConstant;
      }
    };
  }

  return TrueFilter.INSTANCE;
}

@Nullable
public static ElementFilter getReferenceFilter(PsiElement position) {
  // Completion after extends in interface,new NotFilter(new AssignableFromContextFilter()));
  }

  if (ANNOTATION_NAME.accepts(position)) {
    return new AnnotationTypeFilter();
  }

  if (JavaCompletionData.DECLaraTION_START.accepts(position) ||
      JavaCompletionData.isInsideParameterList(position) ||
      psiElement().inside(psiElement(PsiJavaCodeReferenceElement.class).withParent(psiAnnotation())).accepts(position)) {
    return new OrFilter(ElementClassFilter.CLASS,ElementClassFilter.PACKAGE_FILTER);
  }

  if (psiElement().afterLeaf(PsiKeyword.INSTANCEOF).accepts(position)) {
    return new ElementExtractorFilter(ElementClassFilter.CLASS);
  }

  if (JavaCompletionData.VARIABLE_AFTER_FINAL.accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (JavaCompletionData.AFTER_TRY_BLOCK.isAcceptable(position,position) ||
      JavaCompletionData.START_SWITCH.accepts(position) ||
      JavaCompletionData.isinstanceofPlace(position) ||
      JavaCompletionData.isAfterPrimitiveOrArrayType(position)) {
    return null;
  }

  if (JavaCompletionData.START_FOR.accepts(position)) {
    return new OrFilter(ElementClassFilter.CLASS,ElementClassFilter.VARIABLE);
  }

  if (JavaSmartCompletionContributor.AFTER_NEW.accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (psiElement().inside(PsiReferenceParameterList.class).accepts(position)) {
    return ElementClassFilter.CLASS;
  }

  if (psiElement().inside(PsiAnnotationParameterList.class).accepts(position)) {
    return createAnnotationFilter(position);
  }

  if (psiElement().afterLeaf("=").inside(PsiVariable.class).accepts(position)) {
    return new OrFilter(
      new ClassFilter(PsiVariable.class,false),new ExcludeDeclaredFilter(new ClassFilter(PsiVariable.class)));
  }

  if (SWITCH_LABEL.accepts(position)) {
    return new ClassFilter(PsiField.class) {
      @Override
      public boolean isAcceptable(Object element,PsiElement context) {
        return element instanceof PsiEnumConstant;
      }
    };
  }

  return TrueFilter.INSTANCE;
}