net.kaczmarzyk.spring.data.jpa.utils.SpecificationBuilder Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of specification-arg-resolver Show documentation

An alternative API for filtering data with Spring MVC and Spring Data JPA. This library provides a custom HandlerMethodArgumentResolver that transforms HTTP parameters into a Specification object ready to use with Spring Data repositories.

There is a newer version: 3.1.0

Show newest version

/**
 * Copyright 2014-2022 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package net.kaczmarzyk.spring.data.jpa.utils;

import net.kaczmarzyk.spring.data.jpa.web.ProcessingContext;
import net.kaczmarzyk.spring.data.jpa.web.SpecificationFactory;
import net.kaczmarzyk.spring.data.jpa.web.StandaloneProcessingContext;
import org.springframework.data.jpa.domain.Specification;

import java.util.HashMap;
import java.util.Map;

/**
 * SpecificationBuilder allows creating specification apart from web layer.
 * It is recommended to use builder methods that corresponding to the type of argument passed to specification.
 * 
 *  {@code params =  => withParams(, )}, single param argument can provide multiple values 
 *  {@code pathVars =  => withPathVar(, )}, single pathVar argument can provide single value 
 *  {@code headers =  => withHeader(, )}, single header argument can provide single value 
 * 
 * 
 * @author Jakub Radlica
 * @author Kacper Leśniak (Tratif sp. z o.o.)
 */
public class SpecificationBuilder {

	private SpecificationFactory specificationFactory = new SpecificationFactory(null, null);

	private Class specInterface;

	private Map fallbackSpecificationParamValues = new HashMap<>();
	private Map pathVars = new HashMap<>();
	private Map params = new HashMap<>();
	private Map headers = new HashMap<>();
	private Map bodyParams = new HashMap<>();

	private SpecificationBuilder(Class specInterface) {
		this.specInterface = specInterface;
	}

	public static > SpecificationBuilder specification(Class specInterface) {
		return new SpecificationBuilder(specInterface);
	}

	public SpecificationBuilder withSpecificationFactory(SpecificationFactory specificationFactory) {
		this.specificationFactory = specificationFactory;
		return this;
	}

	/**
	 * The direct methods for params/headers/pathVars should be used in most common scenarios in order to avoid
	 * hard-to-debug errors. Use this method only if you really understand how it works.
	 */
	@SuppressWarnings("unckecked")
	public SpecificationBuilder withArg(String arg, String... values) {
		this.fallbackSpecificationParamValues.put(arg, values);
		return this;
	}

	public SpecificationBuilder withParam(String param, String... values) {
		this.params.put(param, values);
		return this;
	}

	public SpecificationBuilder withPathVar(String pathVar, String value) {
		this.pathVars.put(pathVar, value);
		return this;
	}

	public SpecificationBuilder withHeader(String header, String value) {
		this.headers.put(header, value);
		return this;
	}

	public SpecificationBuilder withJsonBodyParam(String jsonPath, String... values) {
		this.bodyParams.put(jsonPath, values);
		return this;
	}

	public T build() {
		ProcessingContext context = createContext();
		return (T) specificationFactory.createSpecificationDependingOn(context);
	}

	private ProcessingContext createContext() {
		return new StandaloneProcessingContext(specInterface, fallbackSpecificationParamValues, pathVars, params, headers, bodyParams);
	}

}