refactored HTTP support into top-level package "org.springframework.http"; revised RestTemplate facility in package "org.springframework.web.client"

Author: jhoeller

org.springframework.core/src/main/java/org/springframework/util/DefaultMultiValueMap.java

@@ -0,0 +1,150 @@
+/*
+ * Copyright 2002-2009 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.util;
+
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * Simple implementation of {@link MultiValueMap} that wraps a plain {@code Map}
+ * (by default a {@link LinkedHashMap}, storing multiple values in a {@link LinkedList}.
+ *
+ * <p>This Map implementation is generally not thread-safe. It is primarily designed
+ * for data structures exposed from request objects, for use in a single thread only.
+ *
+ * @author Arjen Poutsma
+ * @author Juergen Hoeller
+ * @since 3.0
+ */
+public class LinkedMultiValueMap<K, V> implements MultiValueMap<K, V> {
+
+	private final Map<K, List<V>> targetMap;
+
+
+	/**
+	 * Create a new SimpleMultiValueMap that wraps the given target Map.
+	 * @param wrappee the target Map to wrap
+	 */
+	public LinkedMultiValueMap() {
+		this.targetMap = new LinkedHashMap<K, List<V>>();
+	}
+
+	/**
+	 * Create a new SimpleMultiValueMap that wraps the given target Map.
+	 * <p>Note: The given Map will be used as active underlying Map.
+	 * Any changes in the underlying map will be reflected in the
+	 * MultiValueMap object, and vice versa.
+	 * @param targetMap the target Map to wrap
+	 */
+	public LinkedMultiValueMap(Map<K, List<V>> targetMap) {
+		Assert.notNull(targetMap, "'targetMap' must not be null");
+		this.targetMap = targetMap;
+	}
+
+	// MultiValueMap implementation
+
+	public void add(K key, V value) {
+		List<V> values = this.targetMap.get(key);
+		if (values == null) {
+			values = new LinkedList<V>();
+			this.targetMap.put(key, values);
+		}
+		values.add(value);
+	}
+
+	public V getFirst(K key) {
+		List<V> values = this.targetMap.get(key);
+		return (values != null ? values.get(0) : null);
+	}
+
+	public void set(K key, V value) {
+		List<V> values = new LinkedList<V>();
+		values.add(value);
+		this.targetMap.put(key, values);
+	}
+
+
+	// Map implementation
+
+	public int size() {
+		return this.targetMap.size();
+	}
+
+	public boolean isEmpty() {
+		return this.targetMap.isEmpty();
+	}
+
+	public boolean containsKey(Object key) {
+		return this.targetMap.containsKey(key);
+	}
+
+	public boolean containsValue(Object value) {
+		return this.targetMap.containsValue(value);
+	}
+
+	public List<V> get(Object key) {
+		return this.targetMap.get(key);
+	}
+
+	public List<V> put(K key, List<V> value) {
+		return this.targetMap.put(key, value);
+	}
+
+	public List<V> remove(Object key) {
+		return this.targetMap.remove(key);
+	}
+
+	public void putAll(Map<? extends K, ? extends List<V>> m) {
+		this.targetMap.putAll(m);
+	}
+
+	public void clear() {
+		this.targetMap.clear();
+	}
+
+	public Set<K> keySet() {
+		return this.targetMap.keySet();
+	}
+
+	public Collection<List<V>> values() {
+		return this.targetMap.values();
+	}
+
+	public Set<Entry<K, List<V>>> entrySet() {
+		return this.targetMap.entrySet();
+	}
+
+	@Override
+	public boolean equals(Object obj) {
+		return this.targetMap.equals(obj);
+	}
+
+	@Override
+	public int hashCode() {
+		return this.targetMap.hashCode();
+	}
+
+	@Override
+	public String toString() {
+		return this.targetMap.toString();
+	}
+
+}

org.springframework.core/src/main/java/org/springframework/util/LinkedMultiValueMap.java

@@ -28,25 +28,22 @@
 public interface MultiValueMap<K, V> extends Map<K, List<V>> {
 
 	/**
-	 * Adds the given single value to the current list of values for the given key.
-	 *
-	 * @param key   the key
-	 * @param value the value to be added
+	 * Return the first value for the given key.
+	 * @param key the key
+	 * @return the first value for the specified key, or <code>null</code>
 	 */
-	void add(K key, V value);
+	V getFirst(K key);
 
 	/**
-	 * Returns the first value for the given key.
-	 *
+	 * Add the given single value to the current list of values for the given key.
 	 * @param key the key
-	 * @return the first value for the specified key, or <code>null</code>
+	 * @param value the value to be added
 	 */
-	V getFirst(K key);
+	void add(K key, V value);
 
 	/**
-	 * Sets the given single value under the given key.
-	 *
-	 * @param key   the key
+	 * Set the given single value under the given key.
+	 * @param key the key
 	 * @param value the value to set
 	 */
 	void set(K key, V value);

org.springframework.core/src/main/java/org/springframework/util/MultiValueMap.java

@@ -29,13 +29,13 @@
 /**
  * @author Arjen Poutsma
  */
-public class DefaultMultiValueMapTests {
+public class LinkedMultiValueMapTests {
 
-	private DefaultMultiValueMap<String, String> map;
+	private LinkedMultiValueMap<String, String> map;
 
 	@Before
 	public void setUp() {
-		map = new DefaultMultiValueMap<String, String>();
+		map = new LinkedMultiValueMap<String, String>();
 	}
 
 	@Test
@@ -71,7 +71,7 @@ public void set() {
 	public void equals() {
 		map.set("key1", "value1");
 		assertEquals(map, map);
-		MultiValueMap<String, String> o1 = new DefaultMultiValueMap<String, String>();
+		MultiValueMap<String, String> o1 = new LinkedMultiValueMap<String, String>();
 		o1.set("key1", "value1");
 		assertEquals(map, o1);
 		assertEquals(o1, map);
@@ -80,4 +80,5 @@ public void equals() {
 		assertEquals(map, o2);
 		assertEquals(o2, map);
 	}
+
 }

org.springframework.core/src/test/java/org/springframework/util/DefaultMultiValueMapTests.java renamed to org.springframework.core/src/test/java/org/springframework/util/LinkedMultiValueMapTests.java

@@ -39,7 +39,7 @@
 import org.springframework.core.io.Resource;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.MediaType;
+import org.springframework.http.MediaType;
 import org.springframework.util.StringUtils;
 import org.springframework.web.context.request.RequestAttributes;
 import org.springframework.web.context.request.RequestContextHolder;

org.springframework.web.servlet/src/main/java/org/springframework/web/servlet/view/ContentNegotiatingViewResolver.java

@@ -28,7 +28,7 @@
 import org.junit.Test;
 
 import org.springframework.mock.web.MockHttpServletRequest;
-import org.springframework.util.MediaType;
+import org.springframework.http.MediaType;
 import org.springframework.web.context.request.RequestContextHolder;
 import org.springframework.web.context.request.ServletRequestAttributes;
 import org.springframework.web.servlet.View;