神刀安全网

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态…

版权声明:此文章转载自CSDN。 

如需转载请联系听云College团队成员阮小乙,邮箱:ruanqy#tingyun.com

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态操纵Java代码的程序。

能够分析类能力的程序称为反射(reflective)。反射的功能很强大,下面是反射的用途:

  • 在运行中分析类的能力;

  • 在运行中查看对象,例如编写一个toString方法供所有类使用;

  • 实现通用的数组操作代码;

  • 利用Method对象,这个对象很像C++中的函数指针;

1 Class类的使用

Java是面向对象的语言,在Java中,所有的东西都是类(除了静态方法和基本类型)。那么,类是不是一个对象呢?

在Java程序运行期间,Java运行时系统时钟为所有的对象维护一个被称为运行时的类型标志。这个信息跟踪着每个对象的所属类。虚拟机利用运行时类型信息选择相应的方法执行。

Class类保存了Java类的这些信息。官网中,对这个类型称为类的类类型,也就是说一个类的对象。比如,有一个类Student,可以使用下面的代码创建一个实例:

Stuent stu=new Studnet();

即stu是类Student的一个实例。那既然类也是对象,那么Student是什么的实例呢?Student是类Class的一个实例。

可以通过如下三种方法获得一个类的类类型。

(1)getClass方法

如果有一个类的实例,那么可以通过这个实例的getClass方法获得这个类的类类型:

Class cl=stu.getClass();

(2)静态方法forName

forName是Class的一个静态方法,如果没有一个类的实例,但是知道这个类的名字,可以使用这个方法获得这个类的类类型:

Class cl=Class.forName("Student");

如果类名保存在字符串中,并可在运行中改变,就可以使用这个方法。当然,这个方法只有在参数是类名或接口名的时候才能够执行,否则forName方法将抛出一个异常。因此,使用这个方法时,应该处理这个异常。

(3).class

第三个获得类类型 的方法很简单。如果T是任意的Java类型,T.class将代表匹配的类对象。比如:

Class cl1=Student.class;   Class cl2=int.class   Class cl3=Double[].class

注意,一个Class对象实际上表示一个类型,而这个类型不一定是一个类。比如,int不是类,但int.class是一个Class类型的对象。

虚拟机为每个类型管理一个Class对象。因此可以使用==运算符实现两个类对象的比较:

if(stu.getClass()==Student.class)...

这将判断为真。

Class中最常用的一个方法就是getName方法,这个方法将返回类的名字。

还可以通过类类型创建一个类的实例。比如:

Class cl=Student.class;   Student stu=(Student)cl.newInstance();

这就创建了一个Student实例。不过,newInstance方法使用的是默认的构造器(没有参数的构造器)初始化新创建的对象。

使用forName和newInstance方法可以根据存储在字符串中的类名创建一个实例:

String s="java.util.Date";   Object date=Class.forName(s).newInstance();

2 捕获异常

在第一节中,Class类的forName方法可能会抛出一个异常,可以使用下面的代码捕获并处理异常:

try{       String name=...;//get class name       Class cl=Class.forName(name);//might throw exception       do something with cl   }catch(Exception e){       e.printStackTrace();   }

3 利用反射分析类的能力

下面简要的介绍一下反射机制最重要的内容:检查类的结构。

在java.lang.reflect包中有三个类Field、Method和Constructor分别描述类的域、方法和构造器。这三个类都有一个叫getName的方法,用来返回项目的名称。Field类有一个getType方法,用来返回描述域所属的Class对象。Method和Constructor类有能够报告参数类型的方法,Method还有一个可以报告返回类型的方法。这三个类有一个getModifiers的方法,它将返回一个整数值,用不同的位开关描述public和static这样的修饰符的使用状况,还可以利用Modifier.toString方法将修饰符打印出来。

Class类的getFields、getMethods和getCostructors方法可以获得类提供的public域、方法和构造器数组,其中包括超类的共有成员。Class类的getDeclatedFields、getDeclatedMethods和getDeclaredConstructors方法可以获得类中声明的全部域、方法和构造器,其中包括私有和受保护的成员,但不包括超类的成员。

Constructor类:

  • String getName():返回构造器的名字;

  • int getModifiers():返回修饰符;

  • int getParameterCount():返回构造器中参数的个数;

  • Class<?>[] getParameterTypes():返回参数的类型;

Field类:

  • String getName():返回域的名字;

  • int getmodifiers():返回修饰符;

  • Class<?> getType():返回域的类类型;

Method类:

  • String getName():返回方法的名字;

  • int getModifiers():返回修饰符;

  • int getParameterCount():返回参数的个数;

  • Class<?>[] getParameterTypes():返回参数的类类型;

  • Class<?> getReturnType():返回返回类类型;

下面的代码编写了一个可以打印一个类的所有构造器、方法和域的相关信息的类:

package reflection;   import java.lang.reflect.*;   public class PrintClassInfo {       private PrintClassInfo(){}       public static void printClassInfo(String name){           try{               Class cl=Class.forName(name);               Class supercl=cl.getSuperclass();               String modifiers=Modifier.toString(cl.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print("class "+name);               if(supercl!=null&&supercl!=Object.class)System.out.print(" extends "+supercl.getName());               System.out.print("/n{/nConstructors:/n");               printConstructors(cl);               System.out.println("Methods:");               printMethods(cl);               System.out.println("Fields:");               printFields(cl);               System.out.println("}");                }catch(ClassNotFoundException e){               e.printStackTrace();           }           System.exit(0);       }       public static void printConstructors(Class cl){           Constructor[] cons=cl.getConstructors();           for(Constructor c:cons){               String name=c.getName();               System.out.print("    ");               String modifiers=Modifier.toString(c.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print(name+"(");                              Class[] paramTypes=c.getParameterTypes();               for(int i=0;i<paramTypes.length;i++)               {                   if(i>0)System.out.print(", ");                   System.out.print(paramTypes[i].getName());               }               System.out.println(");");           }                    }       public static void printMethods(Class cl){           Method[] methods=cl.getDeclaredMethods();           for(Method m:methods){               Class retType=m.getReturnType();               String name=m.getName();               System.out.print("    ");               String modifiers=Modifier.toString(m.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.print(retType.getName()+" "+name+"(");                              Class[] paramTypes=m.getParameterTypes();               for(int i=0;i<paramTypes.length;i++){                   if(i>0)System.out.print(", ");                   System.out.print(paramTypes[i].getName());               }               System.out.println(");");           }       }        public static void printFields(Class cl){           Field[] fields=cl.getDeclaredFields();           for(Field f:fields){               Class type=f.getType();               String name=f.getName();               System.out.print("    ");               String modifiers=Modifier.toString(f.getModifiers());               if(modifiers.length()>0)System.out.print(modifiers+" ");               System.out.println(type.getName()+" "+name+";");           }       }   }

这个类有一个静态方法printClassInfo,用于打印类的基本信息,在方法的内部调用了printConstructors、printMethosds和printFields方法。测试代码如下:

String name;   System.out.println("Enter the class name:");   Scanner scanner=new Scanner(System.in);   name=scanner.next();   PrintClassInfo.printClassInfo(name);

运行输入java.lang.String,结果如下:

public final class java.lang.String { Constructors:     public java.lang.String([B, int, int);     public java.lang.String([B, java.nio.charset.Charset);     public java.lang.String([B, java.lang.String);     public java.lang.String([B, int, int, java.nio.charset.Charset);     public java.lang.String([B, int, int, java.lang.String);     public java.lang.String(java.lang.StringBuilder);     public java.lang.String(java.lang.StringBuffer);     public java.lang.String([B);     public java.lang.String([I, int, int);     public java.lang.String();     public java.lang.String([C);     public java.lang.String(java.lang.String);     public java.lang.String([C, int, int);      public java.lang.String([B, int);     public java.lang.String([B, int, int, int); Methods:     public boolean equals(java.lang.Object);     public java.lang.String toString();     public int hashCode();     public int compareTo(java.lang.String);     public volatile int compareTo(java.lang.Object);     public int indexOf(java.lang.String, int);     public int indexOf(java.lang.String);     public int indexOf(int, int);     public int indexOf(int);     static int indexOf([C, int, int, [C, int, int, int);     static int indexOf([C, int, int, java.lang.String, int);     public static java.lang.String valueOf(int);     public static java.lang.String valueOf(long);     public static java.lang.String valueOf(float);     public static java.lang.String valueOf(boolean);     public static java.lang.String valueOf([C);     public static java.lang.String valueOf([C, int, int);     public static java.lang.String valueOf(java.lang.Object);     public static java.lang.String valueOf(char);     public static java.lang.String valueOf(double);     public char charAt(int);         private static void checkBounds([B, int, int);     public int codePointAt(int);     public int codePointBefore(int);     public int codePointCount(int, int);     public int compareToIgnoreCase(java.lang.String);     public java.lang.String concat(java.lang.String);     public boolean contains(java.lang.CharSequence);     public boolean contentEquals(java.lang.CharSequence);     public boolean contentEquals(java.lang.StringBuffer);     public static java.lang.String copyValueOf([C);     public static java.lang.String copyValueOf([C, int, int);     public boolean endsWith(java.lang.String);     public boolean equalsIgnoreCase(java.lang.String);     public static transient java.lang.String format(java.util.Locale, java.lang.String, [Ljava.lang.Object;);     public static transient java.lang.String format(java.lang.String, [Ljava.lang.Object;);     public void getBytes(int, int, [B, int);     public [B getBytes(java.nio.charset.Charset);     public [B getBytes(java.lang.String);     public [B getBytes();     public void getChars(int, int, [C, int);     void getChars([C, int);     private int indexOfSupplementary(int, int);     public native java.lang.String intern();     public boolean isEmpty();     public static transient java.lang.String join(java.lang.CharSequence, [Ljava.lang.CharSequence;);     public static java.lang.String join(java.lang.CharSequence, java.lang.Iterable);     public int lastIndexOf(int);     public int lastIndexOf(java.lang.String);     static int lastIndexOf([C, int, int, java.lang.String, int);     public int lastIndexOf(java.lang.String, int);     public int lastIndexOf(int, int);     static int lastIndexOf([C, int, int, [C, int, int, int);     private int lastIndexOfSupplementary(int, int);     public int length();     public boolean matches(java.lang.String);     private boolean nonSyncContentEquals(java.lang.AbstractStringBuilder);     public int offsetByCodePoints(int, int);     public boolean regionMatches(int, java.lang.String, int, int);     public boolean regionMatches(boolean, int, java.lang.String, int, int);     public java.lang.String replace(char, char);     public java.lang.String replace(java.lang.CharSequence, java.lang.CharSequence);     public java.lang.String replaceAll(java.lang.String, java.lang.String);     public java.lang.String replaceFirst(java.lang.String, java.lang.String);     public [Ljava.lang.String; split(java.lang.String);     public [Ljava.lang.String; split(java.lang.String, int);     public boolean startsWith(java.lang.String, int);     public boolean startsWith(java.lang.String);     public java.lang.CharSequence subSequence(int, int);     public java.lang.String substring(int);     public java.lang.String substring(int, int);     public [C toCharArray();     public java.lang.String toLowerCase(java.util.Locale);     public java.lang.String toLowerCase();     public java.lang.String toUpperCase();     public java.lang.String toUpperCase(java.util.Locale);     public java.lang.String trim(); Fields:     private final [C value;     private int hash;     private static final long seria   lVersionUID;     private static final [Ljava.io.ObjectStreamField; serialPersistentFields;     public static final java.util.Comparator CASE_INSENSITIVE_ORDER; }

值得注意的是,这个程序可以分析Java解释器能够加载的任何类,而不仅仅是编译程序时可以使用的类。

4 动态加载类

类的加载有两种方式,一个是在编译时加载的静态加载类,另一个是在运行时加载的动态加载类。当我们使用new来创建一个对象时,使用的是静态加载类,这个时候必须保证类已经实现。而Class的forName方法不但可以获得一个类的类类型,还是一个动态加载类的方法,可以越过编译,在运行时加载一个类。

动态加载有什么好处么?考虑一个场景,比如自己要实现一个办公软件Office,里面有各种组件Word和Excel等。有一个Office工具可以启动各种组件,由于现阶段只有两个组件Word和Excel,那么Office可以这样编写:

class Office   {       public static void main(String[] args)       {           if("Word".equals(args[0]))           {               Word w=new Word();               w.start();           }           if("Excel".equals(args[0]))           {               Excel e=new Excel();               e.start();           }       }   }

这里,根据传进来的参数选择启动哪一个组件。

这里使用的就是静态加载,因为使用new创建的一个对象。不过,如果开发Word的组工作较快,已经完成了开发,代码假如如下:

class Word   {       public void start()       {           System.out.println("Word running...");       }   }

这仅仅打印一句话,但是Excel组开发较慢,还没有开发出来,那么Office还能用么?当然不能,编译Office出错:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

说找不到Excel类。这样,整个的Office都不能使用了。

这时,就可以使用动态加载了。使用Class的forName方法动态加载一个类:

Word w=(Word)Class.forName(args[0]);

不过这里有个问题,就是由于没能事先知道首先实现的是哪个组件,所以不能强制类型转换成Word。那怎么办?就可以使用接口了。定义一个接口OfficeAble,让所有的组件实现这个接口即可:

interface OfficeAble   {       void start();   }

新的Word类如下:

class Word implements OfficeAble   {       public void start()       {           System.out.println("Word running...");       }   }

这样,在OfficeBetter类中就可以使用接口了:

class OfficeBetter   {       public static void main(String[] args)       {           try           {               Class cl=Class.forName(args[0]);               OfficeAble oa=(OfficeAble)cl.newInstance();               oa.start();           }           catch(Exception e)           {               e.printStackTrace();           }       }   }

注意,forName会抛出异常,要进行捕获并处理。

这时,编译Word和OfficeBetter:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

编译没有错误了,运行也正确。

当启动Excel时就会报错:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

说没有找到Excel类。

当Excel实现完后,只需要编译Excel,不需要编译OfficeBetter就可以运行:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

结果正确。这样,使用动态加载类,就可以随时添加功能而不需要重新编译。

5 在运行时使用反射分析对象

现在已经知道了如何查看任意对象的数据域名称和类型:

(1)获得对应的类类型;

(2)通过类类型调用getDeclaredFields方法;

利用反射机制可以查看在编译时还不清楚的对象域。

查看对象域的关键方法是Field类中的get方法。如果f是一个Field类型的对象,obj是某个包含f域的类的对象,f.get(obj)将返回一个对象,其值为obj与的当前值。

既然能够得到域的值,那么也就能设置域的值。可以使用Field类中的set方法设置域的值,用法为f.set(obj,value),obj是包含f域的对象,value是要设置的值。

还要注意,如果f是一个私有域,那么直接使用get方法会抛出一个IllegalAccessException异常。除非拥有访问权限,否则Java安全机制只允许查看任意对象有哪些域而不允许得去域的值。

反射机制的默认行为受限于Java的访问控制。然而,如果一个Java程序没有受到安全管理器的控制,就可以覆盖访问控制。可以调用Field、Method或Constructor类中的setAccessible方法达到这个目的:

f.setAccessible(true);

setAccessible方法是AccessibleObject类中的一个方法,它是Field、Method和Constructor类的超类。

下面的代码演示了使用get和set方法获得和设置域的值:

Student stu=new Student("Bai",20,99);   Class cl=stu.getClass();   Field f=cl.getDeclaredField("name");   f.setAccessible(true);   String stuname=(String)f.get(stu);   System.out.println("The name is:"+stuname);   f.set(stu, "Liu");   System.out.println("The name is:"+(String)f.get(stu));

其中Student类包含String类型的name、int类型的age和double类型的score。

运行结果如下:

The name is:Bai The name is:Liu

即成功获得和设置域的值。

不过get还有一个问题,就是name是一个String,因此把它当做Object返回没有问题。但是如果要返回double的score,double不是对象,这时可以使用Field类中的getDouble方法。此时,反射机制会自动将这个域值打包到相应的对象包装器中。

Field fs=cl.getDeclaredField("score");   fs.setAccessible(true);   System.out.println("The score is:"+fs.getDouble(stu));

结果如下:

The score is:99.0

6 使用invoke调用任意方法

在C和C++中,可以从函数指针执行任意函数。虽然Java没有提供函数指针,但反射机制允许调用任意方法。

和Field中的get方法类似,Method类中有个invoke方法,它允许调用包装在当前Method对象中的方法。invoke方法的签名是:

Object invoke(Object obj,Object... args);

从这里可以看出,invoke方法有个Object类型的返回值,不过,要是调用的方法没有返回值呢,这时invoke放回null。还有,invoke第一个参数是一个对象,第二个参数是一个可变参数,实际上就是一个Object数组。

在一个类中,必须知道哪些信息才能唯一确定一个方法呢?

由于Java中可以有同名的方法,因此可以使用参数来进行区分。不过要注意,返回类型不能作为区分两个函数的依据。因此,在使用Method类中的getMethod和getDeclaredMethod方法时,要给出方法名和方法参数:

Method getMethod(String name,Class... parameterTypes)

下面的例子给出了invoke的使用:

import java.lang.reflect.*;   public class InvokeTest {       public static void main(String[] args) {           A a=new A();           Class cl=a.getClass();           try {               Method m1=cl.getMethod("add", new Class[]{String.class,String.class});               m1.invoke(a, new Object[]{"hello","world"});               Method m2=cl.getMethod("add", int.class,int.class);               m2.invoke(a, 1,2);               Method m3=cl.getMethod("add");               m3.invoke(a);               Method m4=cl.getMethod("add", String.class,int.class);               m4.invoke(null, "Liu",100);           } catch (Exception e) {               // TODO Auto-generated catch block               e.printStackTrace();           }       }   }   class A{       public void add(){           System.out.println("do nothing...");       }       public void add(int a,int b){           System.out.println(a+b);       }       public void add(String a,String b){           System.out.println(a.toUpperCase()+b.toUpperCase());       }       public static void add(String name,int age){           System.out.println(name+" is "+age+" years old.");       }   }

这里定义了一个简单的类A,里面有四个方法名相同的方法add,其中一个是静态方法。这四个方法的返回类型都是void,因此可以通过参数类型进行区分。在测试代码中我们使用getMethod方法获得add方法,其中第一个参数都是add,第二个参数给出参数类型。第二个参数是一个可变参数,即 一个数组,有两种方法给出这个可变参数。

第一种,构造一个Class数组:

Method m1=cl.getMethod("add", new Class[]{String.class,String.class});

还可以直接列出参数,有几个就列出几个,用逗号(,)分隔:

Method m2=cl.getMethod("add", int.class,int.class);

获得Method对象后,就可以调用invoke执行这个方法了。invoke有两个参数,第一个参数给出包含这个方法的对象,第二个参数也是一个可变参数,即传递给要执行的方法的参数。对给出参数可以使用上面两种方法中的一种。

这里要注意的是,对于静态方法,没有包含它的对象,这时第一个参数置为null即可。

运行结果如下:

HELLOWORLD 3 do nothing... Liu is 100 years old.

7 反射与泛型

我们知道,集合中的泛型使得一个集合中只能保存一种类型数据。比如ArrayList<String>只能保存String类型,如果代码中有add(20)就会报错,因为20是int类型,不能转换成String。那么泛型是在哪个阶段起作用呢?

泛型的使用在编写代码中起到了一种类型检查的作用。我们知道,泛型只是编译器的功能,Java虚拟机并没有泛型,也就是说,是不是如果绕过编译,就能在泛型中添加别的类型的数据呢?比如在ArrayList<String>中添加int数据。

下面的代码演示了这种情况:

import java.lang.reflect.*;   import java.util.ArrayList;   public class MethodDemo {       public static void main(String[] args) {           ArrayList list=new ArrayList();           ArrayList<String> list1=new ArrayList<>();                   System.out.println(list.getClass()==list1.getClass());       }   }

上面的代码定义了两个ArrayList,其中list不是泛型,list1是泛型。我们首先检查list和list的类类型是否相同。结果如下:

true

说明在编译阶段是去泛型化的。

接下来修改代码如下:

import java.lang.reflect.*;   import java.util.ArrayList;   public class MethodDemo {       public static void main(String[] args) {           ArrayList list=new ArrayList();           ArrayList<String> list1=new ArrayList<>();                      list.add(10);           list.add("hello");                      list1.add("world");           //list1.add(20);ERROR:can't add int to ArrayList<String>                                 try {           Method m=list1.getClass().getDeclaredMethod("add", Object.class);               m.invoke(list1, 20);               System.out.println(list1.size());               System.out.println(list1);               for(String s:list1){                   System.out.print(s+" ");               }           } catch (Exception e) {               // TODO: handle exception               e.printStackTrace();           }       }   }

直接在list1中使用add添加一个int数据不能成功,编译器会报错。之后使用Method中的getDeclaredMethod方法获得ArrayList<String>中的add方法,然后使用invoke调用这个方法添加一个int数据。这时,编译器没有报错。打印list1的长度和内容,检查是否添加成功。最后使用for循环遍历list1中的内容。结果如下:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

长度为2,内容也正确,说明我们跳过了编译阶段的类型检查,在运行时成功添加了int类型数据。不过,使用for循环遍历是报错了,因为20不是String类型数据。

通过这个例子,可以知道,泛型会在编译时去泛型化。同时可以通过反射在运行阶段添加数据。

8 使用java.lang.reflect包中的Array类编写泛型数组

java.lang.reflect包中的Array类可以动态创建数组。比如,可以将这个特性应用到Array类的copyOf方法实现中。

如果要给一个Student[]数组复制,可以先将Student[]转换为Object[]数组,比如这样:

public static Object[] badCopyOf(Object[] a,int newLength){       Object[] newArray=new Object[newLength];       System.arraycopy(a, 0, newArray, 0, Math.min(a.length, newLength));       return newArray;   }

不过,这样的话,返回的类型是Object[],而Object[]不能转化为Student[]类型。

为了编写通用的方法,需要创建一个与原数组类型相同的新数组。为此,需要java.lang.reflect包中的Array类中的一些方法。

Array类中有一个newInstance方法,能够创建新数组。这个方法要两个参数,一个是数组的元素类型,另一个是数组的长度:

Object newArray=Array.newInstance(componentType,newLength);

这样,就需要获得数组元素的类型和数组的长度。使用Array类中的getComponentType方法可以获得元素的类型,使用Array类中的getLength方法可以获得数组的长度。

下面是完整的代码:

import java.lang.reflect.*;   import java.util.Arrays;   public class CopyOfTest {       public static void main(String[] args) {           int[] a={1,2,3};           a=(int[])goodCopyOf(a,10);           System.out.println(Arrays.toString(a));                      String[] b={"Tom","Dick","Harry"};           b=(String[])goodCopyOf(b,10);           System.out.println(Arrays.toString(b));                      b=(String[])badCopyOf(b,10);       }       public static Object[] badCopyOf(Object[] a,int newLength){           Object[] newArray=new Object[newLength];           System.arraycopy(a, 0, newArray, 0, Math.min(a.length, newLength));           return newArray;       }        public static Object goodCopyOf(Object a,int newLength){           Class cl=a.getClass();           if(!cl.isArray())return null;           Class componentType=cl.getComponentType();           int length=Array.getLength(a);           Object newArray=Array.newInstance(componentType, newLength);           System.arraycopy(a, 0, newArray, 0, Math.min(length, newLength));           return newArray;       }   }

结果如下:

Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态...

注意,应该将goodCopyOf的参数声明为Object类型,而不要声明成Object[]。因为正数数组类型int[]可以转换成Object,但不能转换成对象数组。

想阅读更多技术文章,请访问听云技术博客,访问听云官方网站感受更多应用性能优化魔力。

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » Java中的反射库(reflection library)中提供了一个非常丰富且精心设计的工具集,以便编写能够动态…

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址
分享按钮