JSON解析之Gson

1.Gson简介

  Gson是一个将Java对象转为JSON表示的开源类库,由Google提供,并且也可以讲JSON字符串转为对应的Java对象。虽然有一些其他的开源项目也支持将Java对象转为JSON,可是有些需要把Java注解加到你的代码中,可是如果你不阅读源代码你是不清楚的,而且有些也不是完全支持泛型的。而GSON在设计的时候把这两点都考虑在内了。GSON的目的就是:

  提供简单的toJson()和fromJson()方法将Java对象转为JSON, 反之亦然

  允许已存在的无法改变的类转换成JSON或者是从JSON转为

  大量的支持了Java泛型

  允许为对象定制表示方式

  支持任意复杂的对象

2.引入相关jar包

  最新版本是2.3,这个相应的jar包可以从maven中央仓库获取,下载链接(http://search.maven.org/remotecontent?filepath=com/google/code/gson/gson/2.3/gson-2.3.jar),不过如果不是通过直接添加jar包的方式获取的话可以通过maven或者是gradle,如果是通过maven,需要在pom.xml文件中加上环境配置

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.3</version>
</dependency>

如果是通过gradle那么只需要配置

'com.google.code.gson:gson:2.3'

3.具体的实现

  a):将json转为Java对象

  Google json提供了两种方式来实现,第一种就是用 com.google.gson.Gson类,创建一个这个类的实例然后通过使用方法fromJson(String json, Class<T> classOfT),classOfT  是JSON将要转为的java对象。第二种方式就是使用 com.google.gson.GsonBuilder 类,这个类允许设置一些特定的功能比如允许空序列化,创建一个GsonBuilder,然后设置完通过builder操作Gson类。 

  我们先来看下简单的GSON使用方法,操作的对象实体是Albums.java

public class Albums {
    
    private String title;
    private String message;
    private String[] errors = new String[]{};
    private String total;
    private int total_pages;
    private int page;
    private String limit;
    
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getMessage() {
        return message;
    }
    public void setMessage(String message) {
        this.message = message;
    }
    public String[] getErrors() {
        return errors;
    }
    public void setErrors(String[] errors) {
        this.errors = errors;
    }
    public String getTotal() {
        return total;
    }
    public void setTotal(String total) {
        this.total = total;
    }
    public int getTotal_pages() {
        return total_pages;
    }
    public void setTotal_pages(int total_pages) {
        this.total_pages = total_pages;
    }
    public int getPage() {
        return page;
    }
    public void setPage(int page) {
        this.page = page;
    }
    public String getLimit() {
        return limit;
    }
    public void setLimit(String limit) {
        this.limit = limit;
    }

}

   (需要注意的是errors在为实例化的时候已经赋值了为空值,这个后面有用

通过GSON操作JavaToJsonAndBack.java

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;


public class JavaToJsonAndBack {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        GsonBuilder builder = new GsonBuilder();
        Gson gson = builder.create();
        
        // TODO Auto-generated method stub
        Albums albums = new Albums();
        albums.setTitle("Free Music Archive - Albums");
        albums.setMessage("");
        albums.setTitle("11259");
        albums.setTotal_pages(2252);
        albums.setPage(1);
        albums.setLimit("5");
        System.out.println("Albums");
        System.out.println(gson.toJson(albums));
        
    
    }

}
Albums
{"title":"11259","message":"","errors":[],"total_pages":2252,"page":1,"limit":"5"}

我们注意到的是errors属性打印出来为空但是出现了,现在我们做个小小的改动就是将pojo中Albums中的errors初始化值删掉然后再次运行main方法看打印出来的结果是什么

private String[] errors;


Albums
{"title":"11259","message":"","total_pages":2252,"page":1,"limit":"5"}

我们却发现没有errors这个属性了这个是为什么呢,这个是因为我们在实例化的时候没有给errors赋初值,所以未能实现序列化所以没有值,那么我们有什么办法可以讲errors这个属性即使是空值也能够打印出来呢,方法是有的那就是通过GsonBuilder

来定制,我们设置即使为空也是序列化的.我们将JavaToJsonAndBack.java做个简单修改

import com.google.gson.Gson;
import com.google.gson.GsonBuilder;


public class JavaToJsonAndBack {

    /**
     * @param args
     */
    public static void main(String[] args) {
        
        GsonBuilder builder = new GsonBuilder().serializeNulls();
        Gson gson = builder.create();
        
        // TODO Auto-generated method stub
        Albums albums = new Albums();
        albums.setTitle("Free Music Archive - Albums");
        albums.setMessage("");
        albums.setTitle("11259");
        albums.setTotal_pages(2252);
        albums.setPage(1);
        albums.setLimit("5");
        System.out.println("Albums");
        System.out.println(gson.toJson(albums));
        

    }

}

打印出来的结果是

Albums
{"title":"11259","message":"","errors":null,"total":null,"total_pages":2252,"page":1,"limit":"5"}

可见errors属性出来了,打出来为空

 

这个还可以通过注解的方式实现@SerializedName(""),还可以通过制定NamingStrategy

builder.setFieldNamingStrategy(new FieldNamingStrategy() {
 
            @Override
            public String translateName(Field f) {
                if (f.getName().equals("albumId"))
                    return "album_id";
                else
                    return f.getName();
            }
        });

 

b):标记解析

  通过a我们知道了如果将一个Java对象转为JSON的两种方式,下面介绍下如何解析JSON已经处理特殊的符号,尽管通过JSON构建Java对象看起来是一个很难完成的,但是如果你需要较高级别的去控制这个转化过程的话,它还是很强大的而且是个不错的选择。这个是具有我们通过JsonReader去读取JSON流,下面是一个举例。ParseTokenExample.java

import java.io.IOException;
import java.io.StringReader;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
 
public class ParseTokenExample{
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        //使用reader去读取json

        JsonReader reader = new JsonReader(new StringReader(json));  
    //调用处理对象的方法去处理完整的json对象
        handleObject(reader);     }  
    /**
     *处理对象,假设第一个标记是BEGIN_OBJECT,在对象内部即有可能是数组也有可能不是,我们需要处理这
    *两种情况,需要注意peek()方法,它用于通常用于找出下个标记的类型
     * @param reader
     * @throws IOException
     */    

 


    private static void handleObject(JsonReader reader) throws IOException {
        reader.beginObject();
        while (reader.hasNext()) {
            JsonToken token = reader.peek();
            if (token.equals(JsonToken.BEGIN_ARRAY))
                handleArray(reader);
            else if (token.equals(JsonToken.END_ARRAY)) {
                reader.endObject();
                return;
            } else
                handleNonArrayToken(reader, token);
        }
 
    }
 
    /**
   *处理json数组,第一个标记是 JsonToken_BEGIN_ARRAY,数组可能包含对象或者基本原始类型      *      * @param reader      * @throws IOException      
*/     public static void handleArray(JsonReader reader) throws IOException {         reader.beginArray();         while (true) {             JsonToken token = reader.peek();             if (token.equals(JsonToken.END_ARRAY)) {                 reader.endArray();                 break;             } else if (token.equals(JsonToken.BEGIN_OBJECT)) {                 handleObject(reader);             } else                 handleNonArrayToken(reader, token);         }     }       /**      * 处理不是数组的符号标记      *      * @param reader      * @param token      * @throws IOException      */     public static void handleNonArrayToken(JsonReader reader, JsonToken token) throws IOException {         if (token.equals(JsonToken.NAME))             System.out.println(reader.nextName());         else if (token.equals(JsonToken.STRING))             System.out.println(reader.nextString());         else if (token.equals(JsonToken.NUMBER))             System.out.println(reader.nextDouble());         else             reader.skipValue();     } }

 

c):将JSON对象转为java对象树

  我们可以从一个json串来构建JsonElement(com.google.gson.JsonElement)树,然后这个树可以转为java对象,JsonElement 含有isJsonObjec()以及isJsonNull()方法等等,这些方法可以识别出JsonElement的类型。然后通过getAsJsonObject()和getAsJsonPrimitive()方法可以获取真正的java对象。举例说明:ParseTreeExample.java

 

 
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.JsonArray;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
 
public class ParseTreeExample6 {
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        JsonParser parser = new JsonParser();
     //JsonElement是根节点,它可能是一个对象数组为空或者java原始类型 
        JsonElement element = parser.parse(json);         // 使用isxxx方法来找出jsonelement的类型,在我们的例子中我们知道跟对象是Albums对象并且包含数组对象         if (element.isJsonObject()) {             JsonObject albums = element.getAsJsonObject();             System.out.println(albums.get("title").getAsString());             JsonArray datasets = albums.getAsJsonArray("dataset");             for (int i = 0; i < datasets.size(); i++) {                 JsonObject dataset = datasets.get(i).getAsJsonObject();                 System.out.println(dataset.get("album_title").getAsString());             }         }       } }

 

d):序列化List

  Gson提供了com.google.gson.reflect.TypeToken这个类用于存储泛型类型,举例GenericTypesExample.java

import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
 
public class GenericTypesExample{
    public static void main(String[] args) {
        Animal<dog> animal = new Animal<Dog>();
        Dog dog = new Dog("I am a dog");
 
        animal.setAnimal(dog);
        Gson gson = new Gson();
        //定义一个类型
        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
 
        // 我们首先将animal对象转为json然后从这个json读取回来,但是我们把json定义一个Animal类型
        Animal animal1 = gson.fromJson(gson.toJson(animal, animalType), Animal.class);
        System.out.println(animal1.get().getClass()); 
                                                      
 
        
        Animal animal2 = gson.fromJson(gson.toJson(animal), animalType);
        System.out.println(animal2.get().getClass());
      
 
    }
}
 
Animal.java
 
public class Animal<T> {
 
    public T animal;
 
    public void setAnimal(T animal) {
        this.animal = animal;
    }
 
    public T get() {
        return animal;
    }
 
}

 

Dog.java

public class Dog {
    private String name;
 
    public Dog(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
}

 

e):序列化内部类

  Gson能够序列化内部类和静态嵌套类,通过下面这个例子我们可以看到

    1.序列化含有静态嵌套类

    2.序列化含有非静态嵌套类

    3.反序列化json到一个含有静态非静态内部类的类

    4.序列化静态嵌套类

    5.序列化非静态嵌套类

    6.反序列化json到一个静态嵌套类

    7.反序列化json到一个非静态嵌套类

  举例:SerializeInnerClassExample.java

  

 
import java.lang.reflect.Modifier;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import AlbumsWithInnerClass.Dataset;
import AlbumsWithInnerClass.Dataset2;
 
public class SerializeInnerClassExample {
    public static void main(String[] args) {
        // 创建一个含有静态潜逃类和非静态嵌套类的Albums类
        AlbumsWithInnerClass albums = new AlbumsWithInnerClass();
        albums.setName("SerializeInnerClass");
        //创建一个dataset.因为它不是一个非静态的嵌套类,所以我们需要一个闭合的类型
        Dataset dataset = albums.new Dataset();
        dataset.setAlbum_id("1");
        dataset.setAlbum_name("albums1");
        // 将datasets set到 albums中去
        albums.setDatasetsInner(new Dataset[] { dataset });
 
        // 静态的内部类能够被创建而不需要闭合的类型
        Dataset2 dataset2 = new Dataset2();
        dataset2.setAlbum_id("2");
        dataset2.setAlbum_name("albums2");
        albums.setDatasetsStatic(new Dataset2[] { dataset2 });
 
        // 创建 GsonBuilder
        GsonBuilder builder = new GsonBuilder();
       
        builder.excludeFieldsWithModifiers(Modifier.PRIVATE);
        Gson gson = builder.create();
 
        
        String json = gson.toJson(albums);
        System.out.println(json);
        // 打印的结果为
        // {"name":"SerializeInnerClass","datasetsInner":[{"album_name":"SerializeInnerClass_albums1","album_id":"1"}],
        // "datasetsStatic":[{"album_name":"albums2","album_id":"2"}]}
 
        
        Gson gson3 = new Gson();
        AlbumsWithInnerClass parsedAlbums = gson3.fromJson(json, AlbumsWithInnerClass.class);
        System.out.println(parsedAlbums.datasetsInner[0].album_name);
       
        System.out.println(parsedAlbums.datasetsStatic[0].album_name);
        
 
       
        Gson gson2 = new Gson();
        String json2 = gson2.toJson(dataset);
        System.out.println(json2);
        //打印的结果为 {"album_name":"SerializeInnerClass_albums1","album_id":"1"}
 
    
        String json3 = gson2.toJson(dataset2);
        System.out.println(json3);
        // 打印的结果为 {"album_name":"albums2","album_id":"2"}
 
        // 从json字符串中创建一个内部类
        Gson gson4 = new Gson();
        Dataset parsedDataset = gson4.fromJson(json2, Dataset.class);
        System.out.println(parsedDataset.getClass());
        // 打印结果class com.studytrails.json.gson.AlbumsWithInnerClass$Dataset
        System.out.println(parsedDataset.album_name);
        // 打印结果 SerializeInnerClass_albums1
 
        // 从json中创建一个嵌套的静态类
        Dataset2 parsedStaticNestedClass = gson4.fromJson(json3, Dataset2.class);
        System.out.println(parsedStaticNestedClass.getClass());
        // 打印结果 class com.studytrails.json.gson.AlbumsWithInnerClass$Dataset2
        System.out.println(parsedStaticNestedClass.album_name);
        // 打印结果 albums2
 
    }
}

 

  AlbumsWithInnerClass.java


public class AlbumsWithInnerClass {
    public String name;
    private String year;
    public Dataset[] datasetsInner;
    public Dataset2[] datasetsStatic;
 
    public void setDatasetsInner(Dataset[] datasetsInner) {
        this.datasetsInner = datasetsInner;
    }
 
    public void setDatasetsStatic(Dataset2[] datasetsStatic) {
        this.datasetsStatic = datasetsStatic;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setYear(String year) {
        this.year = year;
    }
 
    class Dataset {
        public String album_name;
        public String album_id;
 
        public void setAlbum_id(String album_id) {
            this.album_id = album_id;
        }
 
        public void setAlbum_name(String album_name) {
            this.album_name = name + "_" + album_name;
        }
    }
 
    static class Dataset2 {
        public String album_name;
        public String album_id;
 
        public void setAlbum_id(String album_id) {
            this.album_id = album_id;
        }
 
        public void setAlbum_name(String album_name) {
            this.album_name = album_name;
        }
    }
}

 

 

 

 

 

f):自定义类型适配器

  自定义类型适配器需要继承com.google.gson.TypeAdapter这个抽象类,实现方法有 public abstract T read(JsonReader in) throws IOException; and public abstract void write(JsonWriter out, T value) throws IOException;你定义的适配器能够处理空值,创建适配器实例后需要在GsonBuilder里面注册,然后通过GsonBuilder来创建Json对象,用于序列化和反序列化操作。举例:

DatasetTypeAdapterExample.java

 
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
 
import org.apache.commons.io.IOUtils;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class DatasetTypeAdapterExample {
 
    public static void main(String[] args) throws MalformedURLException, IOException {
        String url = "http://freemusicarchive.org/api/get/albums.json?api_key=60BLHNQCAOUFPIBZ&limit=5";
        String json = IOUtils.toString(new URL(url));
        // 创建自定义内心适配器并且把它注册到 GsonBuilder
        Gson gson = new GsonBuilder().registerTypeAdapter(Dataset.class, new DatasetTypeAdapter()).create();
    
        Albums albums = gson.fromJson(json, Albums.class);
        System.out.println(albums.getDataset()[1].getAlbum_title());

    }
}
    

 

DatasetTypeAdapter.java

 

import java.io.IOException;
 
import com.google.gson.TypeAdapter;
import com.google.gson.stream.JsonReader;
import com.google.gson.stream.JsonToken;
import com.google.gson.stream.JsonWriter;
 

public class DatasetTypeAdapter extends TypeAdapter<Dataset> {
    @Override
    public Dataset read(JsonReader reader) throws IOException {
       
        JsonToken token = reader.peek();
        Dataset dataset = new Dataset();
        if (token.equals(JsonToken.BEGIN_OBJECT)) {
            reader.beginObject();
            while (!reader.peek().equals(JsonToken.END_OBJECT)) {
                if (reader.peek().equals(JsonToken.NAME)) {
                    if (reader.nextName().equals("album_url"))
                        dataset.setAlbum_title(reader.nextString());
                    else
                        reader.skipValue();
 
                }
            }
            reader.endObject();
 
        }
        return dataset;
    }
 
    @Override
    public void write(JsonWriter out, Dataset value) throws IOException {
 
    }
 
}

 

Albums.java

 

public class Albums {
 
    private String title;
    private Dataset[] dataset;
 
    public void setTitle(String title) {
        this.title = title;
    }
 
    public void setDataset(Dataset[] dataset) {
        this.dataset = dataset;
    }
 
    public String getTitle() {
        return title;
    }
 
    public Dataset[] getDataset() {
        return dataset;
    }
}

 

g):自定义序列化器

   创建一个自定义的序列化器需要实现com.studytrails.json.gson.JsonSerializer  接口,然后实现 public JsonElement serialize(T src, Type typeOfSrc, JsonSerializationContext context); 方法,src 是指源对象,Type 是指源对象的类型,举例:

 

DogSerializer.java

 
import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonSerializationContext;
import com.google.gson.JsonSerializer;
import com.google.gson.reflect.TypeToken;
 
public class DogSerializer implements JsonSerializer<dog> {
    @Override
    public JsonElement serialize(Dog src, Type typeOfSrc, JsonSerializationContext context) {
    
        JsonObject object = new JsonObject();
        String name = src.getName().replaceAll(" ", "_");
        object.addProperty("name", name);
    
        return object;
    }
 
    public static void main(String[] args) {
        Animall<Dog> animal = new Animall<Dog>();
        Dog dog = new Dog("I am a dog");
        animal.setAnimal(dog);

        Gson gson = new GsonBuilder().registerTypeAdapter(Dog.class, new DogSerializer()).setPrettyPrinting().create();

        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
        System.out.println(gson.toJson(animal, animalType));
    }
}

Animal.java

public class Animal<t> {
 
    public T animal;
 
    public void setAnimal(T animal) {
        this.animal = animal;
    }
 
    public T get() {
        return animal;
    }
 
}
 

 

Dog.java

 

public class Dog {
    private String name;
 
    public Dog(String name) {
        this.name = name;
    }
 
    public String getName() {
        return name;
    }
 
}

h):自定义反序列化器

  创建一个反序列化器需要实现的方法有 public T deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException;举例:

  DogDeserialiser.java

  

 
import java.lang.reflect.Type;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonDeserializer;
import com.google.gson.JsonElement;
import com.google.gson.JsonParseException;
import com.google.gson.reflect.TypeToken;
 
public class DogDeserialiser implements JsonDeserializer<Dog> {
    @Override
    public Dog deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
        String name = json.getAsJsonObject().get("name").getAsString();
        name = name.replace(" ", "_");
        Dog dog = new Dog(name);
 
        return dog;
    }
 
    public static void main(String[] args) {
        String json = "{\"animal\":{\"name\":\"I am a dog\"}}";
        Gson gson = new GsonBuilder().registerTypeAdapter(Dog.class, new DogDeserialiser()).create();
        Type animalType = new TypeToken<Animal<Dog>>() {
        }.getType();
        Animal<Dog> animal = gson.fromJson(json, animalType);
        System.out.println(animal.get().getName());
    }
 
}
     
    

i):GSON扩展策略

  在缺省的情况下,GSON试着将java对象中的所有属性映射到json中相一致的属性中。但是在一些特殊的情况下我们尝试去控制这个操作。这个是有一些方法实现的。

  1.通过自定义注解的方式并且忽略被注解的域。

  2.通过集成ExclusionStrategy 接口的方式自定义来实现,需要实现的方法有public boolean shouldSkipField(FieldAttributes f); and public boolean   shouldSkipClass(Class clazz);

  3.通过使用@Expose 注解,然后在GsonBuilder上面使用excludeFieldsWithoutExposeAnnotation(),这个方法,除非使用 @Expose 这个注解,否 则我们忽略所有的域。

  举例:ExclusionExample.java

 
import java.awt.Color;
 
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
 
public class ExclusionExample {
    public static void main(String[] args) {
        
        Cat cat = new Cat();
        cat.setName("Cat");
        cat.setAge(1);
        cat.setColor(Color.BLACK);
        cat.setCountry("US");

        Gson gson = new GsonBuilder().serializeNulls().setExclusionStrategies(new CustomExclusionStrategy(Color.class))
                .excludeFieldsWithoutExposeAnnotation().create();
        System.out.println(gson.toJson(cat));
        // 打印结果 {"name":"Cat","lazy":null}
 
    }
}

 

Cat.java

 

import java.awt.Color;
 
import com.google.gson.annotations.Expose;
 
public class Cat {
    @Expose
    private String name;
    private int age;
    private Color color;
    @Expose
    @Country
    private String country;
    @Expose
    private Boolean lazy = null;
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setColor(Color color) {
        this.color = color;
    }
 
    public int getAge() {
        return age;
    }
 
    public String getName() {
        return name;
    }
 
    public Color getColor() {
        return color;
    }
 
    public void setCountry(String country) {
        this.country = country;
    }
 
    public String getCountry() {
        return country;
    }
 
    public void setLazy(Boolean lazy) {
        this.lazy = lazy;
    }
 
    public Boolean getLazy() {
        return lazy;
    }
}

 

CustomExclusionStrategy.java

 

 
import com.google.gson.ExclusionStrategy;
import com.google.gson.FieldAttributes;
 

public class CustomExclusionStrategy implements ExclusionStrategy {
 
    private Class classToExclude;
 
    public CustomExclusionStrategy(Class classToExclude) {
        this.classToExclude = classToExclude;
    }
 

    @Override
    public boolean shouldSkipField(FieldAttributes f) {
        if (f.getAnnotation(Country.class) == null)
            return false;
 
        return true;
    }

    @Override
    public boolean shouldSkipClass(Class<?> clazz) {
        if (clazz.equals(classToExclude))
            return true;
        return false;
    }
 
}

 

4.结束

  Gson功能的强大可见一斑,而且很是简介,毕竟是大牌厂商的产品,果然是不一样,当然还有很多功能有待挖掘,最好的是阅读源码,这样可以收获更大。

posted on 2014-11-20 15:00  叼烟斗的纤夫  阅读(4230)  评论(0编辑  收藏  举报