最近瘋狂搞項(xiàng)目,然后出現(xiàn)了各種小問題,記錄一下
1.POST傳遞參數(shù) ：采用 LinkedMultiValueMap ，不能使用HashMap

String url = 'http://posturl';
MultiValueMap<String, String> map= new LinkedMultiValueMap<String, String>();        
map.add("shopid","1");       
HttpHeaders headers = new HttpHeaders();       
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);        
HttpEntity<MultiValueMap<String, String>> request = new HttpEntity<MultiValueMap<String, String>>(map, headers);        
return restTemplate.postForEntity(url, request,String.class);

注意 上面的請(qǐng)求支持參數(shù)類型均為String類型，如果MultiValueMap<String, Object> LinkedMultiValueMap 會(huì)將value放進(jìn)list中，key --> [value]

2. 采用JSONObject或者實(shí)體類傳遞參數(shù)

  RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        MediaType type = MediaType.parseMediaType("application/json; charset=UTF-8");
        headers.setContentType(type);
        headers.add("Accept", MediaType.APPLICATION_JSON.toString());
        
        JSONObject param = new JSONObject();
        param.put("username", "123");
        
        HttpEntity<String> formEntity = new HttpEntity<String>(param, headers);
 
        String result = restTemplate.postForObject(url, formEntity, String.class);

使用這種方式可以傳遞任意類型的參數(shù)，避免上面的情況
源碼:

  public class LinkedMultiValueMap<K, V> implements MultiValueMap<K, V>, Serializable, Cloneable {
    private static final long serialVersionUID = 3801124242820219131L;
    private final Map<K, List<V>> targetMap;
 
    public LinkedMultiValueMap() {
        this.targetMap = new LinkedHashMap();
    }
 
    public LinkedMultiValueMap(int initialCapacity) {
        this.targetMap = new LinkedHashMap(initialCapacity);
    }
 
    public LinkedMultiValueMap(Map<K, List<V>> otherMap) {
        this.targetMap = new LinkedHashMap(otherMap);
    }
 
    @Nullable
    public V getFirst(K key) {
        List<V> values = (List)this.targetMap.get(key);
        return values != null && !values.isEmpty() ? values.get(0) : null;
    }
 
    public void add(K key, @Nullable V value) {
        List<V> values = (List)this.targetMap.computeIfAbsent(key, (k) -> {
            return new LinkedList();
        });
        values.add(value);
    }
    public void addAll(K key, List<? extends V> values) {
        List<V> currentValues = (List)this.targetMap.computeIfAbsent(key, (k) -> {
            return new LinkedList();
        });
        currentValues.addAll(values);
    }
    public void addAll(MultiValueMap<K, V> values) {
        Iterator var2 = values.entrySet().iterator();
        while(var2.hasNext()) {
            Entry<K, List<V>> entry = (Entry)var2.next();
            this.addAll(entry.getKey(), (List)entry.getValue());
        }
    }
    public void set(K key, @Nullable V value) {
        List<V> values = new LinkedList();
        values.add(value);
        this.targetMap.put(key, values);
    }
    public void setAll(Map<K, V> values) {
        values.forEach(this::set);
    }
    public Map<K, V> toSingleValueMap() {
        LinkedHashMap<K, V> singleValueMap = new LinkedHashMap(this.targetMap.size());
        this.targetMap.forEach((key, values) -> {
            if (values != null && !values.isEmpty()) {
                singleValueMap.put(key, values.get(0));
            }
 
        });
        return singleValueMap;
    }