#572 - Create SimpleResourceAssembler for Resource<T>.

Implement a ResourceAssembler that returns a Resource<T> solely based on a non-Resource domain class.

Related issues: #416

Author: gregturn

src/main/java/org/springframework/hateoas/ResourceAssembler.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012 the original author or authors.
+ * Copyright 2012-2018 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.
@@ -27,7 +27,7 @@
 public interface ResourceAssembler<T, D extends ResourceSupport> {
 
 	/**
-	 * Converts the given entity into an {@link ResourceSupport}.
+	 * Converts the given entity into a {@code D}, which extends {@link ResourceSupport}.
 	 * 
 	 * @param entity
 	 * @return
@@ -38,10 +38,10 @@ public interface ResourceAssembler<T, D extends ResourceSupport> {
 	 * Converts an {@link Iterable} or {@code T}s into an {@link Iterable} of {@link ResourceSupport} and wraps
 	 * them in a {@link Resources} instance.
 	 * 
-	 * @param entities
-	 * @return
+	 * @param entities must not be {@literal null}.
+	 * @return {@link Resources} containing {@code D}.
 	 */
-	default Resources<D> toResources(List<T> entities) {
+	default Resources<D> toResources(Iterable<? extends T> entities) {
 
 		List<D> resources = new ArrayList<>();
 		for (T entity : entities) {

src/main/java/org/springframework/hateoas/SimpleResourceAssembler.java

@@ -0,0 +1,89 @@
+/*
+ * Copyright 2017-2018 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 org.springframework.hateoas;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.springframework.util.Assert;
+
+/**
+ * A {@link ResourceAssembler} that focuses purely on the domain type,
+ * returning back {@link Resource} and {@link Resources} for that type instead of
+ * {@link ResourceSupport}.
+ *
+ * @author Greg Turnquist
+ */
+public class SimpleResourceAssembler<T> implements ResourceAssembler<T, Resource<T>> {
+
+	/**
+	 * Converts the given entity into a {@link Resource}.
+	 *
+	 * @param entity
+	 * @return
+	 */
+	@Override
+	public Resource<T> toResource(T entity) {
+		
+		Resource<T> resource = new Resource<T>(entity);
+		addLinks(resource);
+		return resource;
+	}
+
+	/**
+	 * Converts all given entities into resources and wraps the collection as a resource as well.
+	 *
+	 * @see #toResource(Object)
+	 * @param entities must not be {@literal null}.
+	 * @return {@link Resources} containing {@link Resource} of {@code T}.
+	 */
+	@Override
+	public Resources<Resource<T>> toResources(Iterable<? extends T> entities) {
+
+		Assert.notNull(entities, "Entities must not be null!");
+		List<Resource<T>> result = new ArrayList<Resource<T>>();
+
+		for (T entity : entities) {
+			result.add(toResource(entity));
+		}
+
+		Resources<Resource<T>> resources = new Resources<>(result);
+		addLinks(resources);
+		return resources;
+	}
+
+	/**
+	 * Define links to add to every individual {@link Resource}.
+	 *
+	 * @see org.springframework.hateoas.mvc.SimpleIdentifiableResourceAssembler#addLinks(Resource)
+	 *
+	 * @param resource
+	 */
+	protected void addLinks(Resource<T> resource) {
+		// Default adds no links
+	}
+
+	/**
+	 * Define links to add to the {@link Resources} collection.
+	 *
+	 * @see org.springframework.hateoas.mvc.SimpleIdentifiableResourceAssembler#addLinks(Resources) 
+	 * 
+	 * @param resources
+	 */
+	protected void addLinks(Resources<Resource<T>> resources) {
+		// Default adds no links.
+	}
+}

src/main/java/org/springframework/hateoas/mvc/ResourceAssemblerSupport.java

@@ -33,7 +33,8 @@
  * @author Oliver Gierke
  * @author Greg Turnquist
  */
-public abstract class ResourceAssemblerSupport<T, D extends ResourceSupport> implements ResourceAssembler<T, D> {
+public abstract class ResourceAssemblerSupport<T, D extends ResourceSupport>
+	implements ResourceAssembler<T, D> {
 
 	private final Class<?> controllerClass;
 	private final Class<D> resourceType;
@@ -53,8 +54,15 @@ public ResourceAssemblerSupport(Class<?> controllerClass, Class<D> resourceType)
 		this.resourceType = resourceType;
 	}
 
+	/**
+	 * Converts all given entities into resources.
+	 *
+	 * @see #toResource(Object)
+	 * @param entities must not be {@literal null}.
+	 * @return
+	 */
 	@Override
-	public Resources<D> toResources(List<T> entities) {
+	public Resources<D> toResources(Iterable<? extends T> entities) {
 		return this.map(entities).toResources();
 	}
 

src/main/java/org/springframework/hateoas/mvc/SimpleIdentifiableResourceAssembler.java

@@ -0,0 +1,157 @@
+/*
+ * Copyright 2017 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 org.springframework.hateoas.mvc;
+
+import static org.springframework.hateoas.mvc.ControllerLinkBuilder.*;
+
+import org.springframework.core.GenericTypeResolver;
+import org.springframework.hateoas.Identifiable;
+import org.springframework.hateoas.Link;
+import org.springframework.hateoas.LinkBuilder;
+import org.springframework.hateoas.RelProvider;
+import org.springframework.hateoas.Resource;
+import org.springframework.hateoas.Resources;
+import org.springframework.hateoas.SimpleResourceAssembler;
+import org.springframework.hateoas.core.EvoInflectorRelProvider;
+
+/**
+ * Using a Spring MVC-based {@link ControllerLinkBuilder} and an {@link Identifiable} domain object, construct
+ * a {@link SimpleResourceAssembler}.
+ *
+ * @author Greg Turnquist
+ */
+public class SimpleIdentifiableResourceAssembler<T extends Identifiable<?>> extends SimpleResourceAssembler<T> {
+
+	/**
+	 * The Spring MVC class for the {@link Identifiable} from which links will be built.
+	 */
+	private final Class<?> controllerClass;
+
+	/**
+	 * A {@link RelProvider} to look up names of links as options for resource paths.
+	 */
+	private final RelProvider relProvider;
+
+	/**
+	 * A {@link Class} depicting the {@link Identifiable}'s type.
+	 */
+	private final Class<?> resourceType;
+
+	/**
+	 * Default base path as empty.
+	 */
+	private String basePath = "";
+
+	/**
+	 * Default assembler based on a Spring MVC controller, resource type, and {@link RelProvider}. With this combination
+	 * of information, resources can be defined.
+	 *
+	 * @see #setBasePath(String) to adjust base path to something like "/api"/
+	 *
+	 * @param controllerClass - Spring MVC controller to base links off of
+	 * @param relProvider - generates the links items
+	 */
+	public SimpleIdentifiableResourceAssembler(Class<?> controllerClass, RelProvider relProvider) {
+
+		this.controllerClass = controllerClass;
+		this.relProvider = relProvider;
+
+		// Find the "T" type contained in "T extends Identifiable<?>", e.g. SimpleIdentifiableResourceAssembler<User> -> User
+		this.resourceType = GenericTypeResolver.resolveTypeArgument(this.getClass(), SimpleIdentifiableResourceAssembler.class);
+	}
+
+	/**
+	 * Alternate constructor that falls back to {@link EvoInflectorRelProvider}.
+	 * 
+	 * @param controllerClass
+	 */
+	public SimpleIdentifiableResourceAssembler(Class<?> controllerClass) {
+		this(controllerClass, new EvoInflectorRelProvider());
+	}
+
+	/**
+	 * Define links to add to every {@link Resource}.
+	 *
+	 * @param resource
+	 */
+	@Override
+	protected void addLinks(Resource<T> resource) {
+
+		Link resourceSelfLink = getCollectionLinkBuilder().slash(resource.getContent()).withSelfRel();
+		Link resourceCollectionLink = getCollectionLinkBuilder().withRel(this.relProvider.getCollectionResourceRelFor(this.resourceType));
+
+		resource.add(resourceSelfLink, resourceCollectionLink);
+	}
+
+	/**
+	 * Define links to add to {@link Resources} collection.
+	 *
+	 * @param resources
+	 */
+	@Override
+	protected void addLinks(Resources<Resource<T>> resources) {
+
+		Link resourceCollectionLink = getCollectionLinkBuilder().withSelfRel();
+		resources.add(resourceCollectionLink);
+	}
+
+	/**
+	 * Build up a URI for the collection using the Spring MVC controller followed by the resource type transformed
+	 * by the {@link RelProvider}.
+	 *
+	 * Assumption is that a {@literal EmployeeController} serving up {@literal Employee}
+	 * objects will be serving resources at {@code /employees} and {@code /employees/1} respectively.
+	 *
+	 * If this is not the case, simply override this method in your concrete instance, or simply resort to
+	 * overriding {@link #addLinks(Resource)} and {@link #addLinks(Resources)} where you have full control over exactly
+	 * what links are put in the individual and collection resources.
+	 *
+	 * @return
+	 */
+	protected LinkBuilder getCollectionLinkBuilder() {
+
+		String[] pathComponents = (getPrefix() + this.relProvider.getCollectionResourceRelFor(this.resourceType)).split("/");
+
+		ControllerLinkBuilder linkBuilder = linkTo(this.controllerClass);
+
+		for (String pathComponent : pathComponents) {
+			if (!pathComponent.isEmpty()) {
+				linkBuilder = linkBuilder.slash(pathComponent);
+			}
+		}
+
+		return linkBuilder;
+	}
+
+	/**
+	 * Construct the prefix to a resource, with {@literal "/"} being the basis for no prefix at all.
+	 *
+	 * @return
+	 */
+	private String getPrefix() {
+		return getBasePath().isEmpty() ? "" : getBasePath() + "/";
+	}
+
+	public String getBasePath() {
+		return this.basePath;
+	}
+
+	public void setBasePath(String basePath) {
+		this.basePath = basePath;
+	}
+
+
+}