/** * Type-safe alternative to {@link #forBasePackage(String...)} to specify a * base package through a class. * @param packageClasses one or more base package classes */ public static HandlerTypePredicate forBasePackageClass(Class<?>... packageClasses) { return new Builder().basePackageClass(packageClasses).build(); }
/** * Match handlers that are assignable to a given type. * @param types one or more handler super types */ public static HandlerTypePredicate forAssignableType(Class<?>... types) { return new Builder().assignableType(types).build(); }
@Override public ReturnValueMethodParameter clone() { return new ReturnValueMethodParameter(this); } }
@Test(expected = ServletRequestBindingException.class) public void resolveArgumentRequired() throws Exception { MethodParameter param = this.testMethod.annot(matrixAttribute().noName()).arg(List.class, String.class); this.resolver.resolveArgument(param, this.mavContainer, this.webRequest, null); }
@Test public void markerClassSupport() { ControllerAdviceBean bean = new ControllerAdviceBean(new MarkerClassSupport()); assertApplicable("base package class support", bean, AnnotatedController.class); assertApplicable("base package class support", bean, ImplementationController.class); assertApplicable("base package class support", bean, InheritanceController.class); assertNotApplicable("bean not in package", bean, String.class); }
@Test public void basePackageSupport() { ControllerAdviceBean bean = new ControllerAdviceBean(new BasePackageSupport()); assertApplicable("base package support", bean, AnnotatedController.class); assertApplicable("base package support", bean, ImplementationController.class); assertApplicable("base package support", bean, InheritanceController.class); assertNotApplicable("bean not in package", bean, String.class); }
@Test public void basePackageValueSupport() { ControllerAdviceBean bean = new ControllerAdviceBean(new BasePackageValueSupport()); assertApplicable("base package support", bean, AnnotatedController.class); assertApplicable("base package support", bean, ImplementationController.class); assertApplicable("base package support", bean, InheritanceController.class); assertNotApplicable("bean not in package", bean, String.class); }
@Test public void assignableTypesSupport() { ControllerAdviceBean bean = new ControllerAdviceBean(new AssignableTypesSupport()); assertApplicable("controller implements assignable", bean, ImplementationController.class); assertApplicable("controller inherits assignable", bean, InheritanceController.class); assertNotApplicable("not assignable", bean, AnnotatedController.class); assertNotApplicable("not assignable", bean, String.class); }
@Test public void multipleMatch() { ControllerAdviceBean bean = new ControllerAdviceBean(new MultipleSelectorsSupport()); assertApplicable("controller implements assignable", bean, ImplementationController.class); assertApplicable("controller is annotated", bean, AnnotatedController.class); assertNotApplicable("should not match", bean, InheritanceController.class); }
@Test public void annotationSupport() { ControllerAdviceBean bean = new ControllerAdviceBean(new AnnotationSupport()); assertApplicable("annotation support", bean, AnnotatedController.class); assertNotApplicable("this bean is not annotated", bean, InheritanceController.class); }
@Test public void shouldNotMatch() { ControllerAdviceBean bean = new ControllerAdviceBean(new ShouldNotMatch()); assertNotApplicable("should not match", bean, AnnotatedController.class); assertNotApplicable("should not match", bean, ImplementationController.class); assertNotApplicable("should not match", bean, InheritanceController.class); assertNotApplicable("should not match", bean, String.class); }
@Test public void shouldMatchAll() { ControllerAdviceBean bean = new ControllerAdviceBean(new SimpleControllerAdvice()); assertApplicable("should match all", bean, AnnotatedController.class); assertApplicable("should match all", bean, ImplementationController.class); assertApplicable("should match all", bean, InheritanceController.class); assertApplicable("should match all", bean, String.class); }
/** * Shortcut to the unique return type equivalent to: * <p>{@code returning(returnType).build().returnType()} * @param returnType the return type * @param generic at least one generic type * @param generics optional extra generic types */ public MethodParameter resolveReturnType(Class<?> returnType, ResolvableType generic, ResolvableType... generics) { return returning(returnType, generic, generics).build().returnType(); }
@Override public int getOrder() { return this.adviceBean.getOrder(); } }
/** * Resolve and return the declared return type equivalent to: * <p>{@code build().returnType()} */ public final MethodParameter resolveReturnType() { return build().returnType(); }
/** * Create a {@code ResolvableMethod} builder for the given handler class. */ public static <T> Builder<T> on(Class<T> objectClass) { return new Builder<>(objectClass); }
/** * Shortcut to the unique return type equivalent to: * <p>{@code returning(returnType).build().returnType()} * @param returnType the return type * @param generics optional array of generic types */ public MethodParameter resolveReturnType(Class<?> returnType, Class<?>... generics) { return returning(returnType, generics).build().returnType(); }
public MethodParameter resolveReturnType(ResolvableType returnType) { return returning(returnType).build().returnType(); }