<rt id="bn8ez"></rt>
<label id="bn8ez"></label>
  • 

    • <span id="bn8ez"></span>
    

    <label id="bn8ez"><meter id="bn8ez"></meter></label>
    

    
    

    




    







												


        


    


    dream.in.java
    

    能以不變應萬變是聰明人做事的準則。萬事從小事做起，積累小成功，問鼎大成功，是成功者的秘訣。
    

    




    
	
					
	
    
		
    
			深入了解Java ClassLoader、Bytecode 、ASM、cglib
		
    
		

    

    

    Java代碼 復制代碼
    

    

      
    
    1. import java.io.ByteArrayOutputStream;   
      2. 
    
    2. import java.io.File;   
      3. 
    
    3. import java.io.FileInputStream;   
      4. 
    
    4. import java.io.IOException;   
      5. 
    
    5.   
      6. 
    
    6. public class FileClassLoader extends ClassLoader {   
      7. 
    
    7.   public Class findClass(String name) {   
      8. 
    
    8.     byte[] data = loadClassData(name);   
      9. 
    
    9.     return defineClass(name, data, 0, data.length);   
      10. 
    
    10.   }   
      11. 
    
    11.      
      12. 
    
    12.   private byte[] loadClassData(String name) {   
      13. 
    
    13.     FileInputStream fis = null;   
      14. 
    
    14.     byte[] data = null;   
      15. 
    
    15.     try {   
      16. 
    
    16.       fis = new FileInputStream(new File("D:\\project\\test\\" + name + ".class"));   
      17. 
    
    17.       ByteArrayOutputStream baos = new ByteArrayOutputStream();   
      18. 
    
    18.       int ch = 0;   
      19. 
    
    19.       while ((ch = fis.read()) != -1) {   
      20. 
    
    20.         baos.write(ch);   
      21. 
    
    21.       }   
      22. 
    
    22.       data = baos.toByteArray();   
      23. 
    
    23.     } catch (IOException e) {   
      24. 
    
    24.       e.printStackTrace();   
      25. 
    
    25.     }   
      26. 
    
    26.     return data;   
      27. 
    
    27.   }   
      28. 
    
    28. }  
      29. 

    

    


    
MyApp.java: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. public class MyApp {   
      2. 
    
    2.   public static void main(String[] args) throws Exception {   
      3. 
    
    3.     FileClassLoader loader = new FileClassLoader();   
      4. 
    
    4.     Class objClass = loader.findClass("MyApp");   
      5. 
    
    5.     Object obj = objClass.newInstance();   
      6. 
    
    6.     System.out.println(objClass.getName());   
      7. 
    
    7.     System.out.println(objClass.getClassLoader());   
      8. 
    
    8.     System.out.println(obj);   
      9. 
    
    9.   }   
      10. 
    
    10. }  
      11. 

    

    


    
編譯并運行MyApp類，結果為: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. MyApp   
      2. 
    
    2. FileClassLoader@757aef  
      3. 
    
    3. MyApp@9cab16  
      4. 

    

    

    

    

    
二、Bytecode 
    

    
1，什么是Bytecode 
    
C/C++編譯器把源代碼編譯成匯編代碼，Java編譯器把Java源代碼編譯成字節碼bytecode。 
    
Java跨平臺其實就是基于相同的bytecode規范做不同平臺的虛擬機，我們的Java程序編譯成bytecode后就可以在不同平臺跑了。 
    
.net框架有IL(intermediate language)，匯編是C/C++程序的中間表達方式，而bytecode可以說是Java平臺的中間語言。 
    
了解Java字節碼知識對debugging、performance tuning以及做一些高級語言擴展或框架很有幫助。 
    

    
2，使用javap生成Bytecode 
    
JDK自帶的javap.exe文件可以反匯編Bytecode，讓我們看個例子: 
    
Test.java: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. public class Test {   
      2. 
    
    2.   public static void main(String[] args) {   
      3. 
    
    3.     int i = 10000;   
      4. 
    
    4.     System.out.println("Hello Bytecode! Number = " + i);   
      5. 
    
    5.   }   
      6. 
    
    6. }  
      7. 

    

    


    
編譯后的Test.class: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. 漱壕   1 +   
      2. 
    
    2.            
      3. 
    
    3.       
      4. 
    
    4.      
      5. 
    
    5.      
      6. 
    
    6.      
      7. 
    
    7.      <init> ()V Code LineNumberTable main ([Ljava/lang/String;)V    
      8. 
    
    8. SourceFile   Test.java       
      9. 
    
    9.     ! " java/lang/StringBuilder Hello Bytecode! Number =   # $  # %  & ' (  ) * Test java/lang/Object java/lang/System out Ljava/io/PrintStream; append -(Ljava/lang/String;)Ljava/lang/StringBuilder; (I)Ljava/lang/StringBuilder; toString ()Ljava/lang/String; java/io/PrintStream println (Ljava/lang/String;)V !    
      10. 
    
    10.               
      11. 
    
    11.           *                      >     '<  Y                              
      12. 

    

    


    
使用javap -c Test > Test.bytecode生成的Test.bytecode: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. Compiled from "Test.java"  
      2. 
    
    2. public class Test extends java.lang.Object{   
      3. 
    
    3. public Test();   
      4. 
    
    4.   Code:   
      5. 
    
    5.    0:  aload_0   
      6. 
    
    6.    1:  invokespecial  #1; //Method java/lang/Object."<init>":()V   
      7. 
    
    7.    4:  return  
      8. 
    
    8.   
      9. 
    
    9. public static void main(java.lang.String[]);   
      10. 
    
    10.   Code:   
      11. 
    
    11.    0:  sipush  10000  
      12. 
    
    12.    3:  istore_1   
      13. 
    
    13.    4:  getstatic  #2; //Field java/lang/System.out:Ljava/io/PrintStream;   
      14. 
    
    14.    7:  new  #3; //class java/lang/StringBuilder   
      15. 
    
    15.    10:  dup   
      16. 
    
    16.    11:  invokespecial  #4; //Method java/lang/StringBuilder."<init>":()V   
      17. 
    
    17.    14:  ldc  #5; //String Hello Bytecode! Number =    
      18. 
    
    18.    16:  invokevirtual  #6; //Method java/lang/StringBuilder.append:(Ljava/lang/String;)Ljava/lang/StringBuilder;   
      19. 
    
    19.    19:  iload_1   
      20. 
    
    20.    20:  invokevirtual  #7; //Method java/lang/StringBuilder.append:(I)Ljava/lang/StringBuilder;   
      21. 
    
    21.    23:  invokevirtual  #8; //Method java/lang/StringBuilder.toString:()Ljava/lang/String;   
      22. 
    
    22.    26:  invokevirtual  #9; //Method java/io/PrintStream.println:(Ljava/lang/String;)V   
      23. 
    
    23.    29:  return  
      24. 
    
    24.   
      25. 
    
    25. }  
      26. 

    

    


    
JVM就是一個基于stack的機器，每個thread擁有一個存儲著一些frames的JVM stack，每次調用一個方法時生成一個frame。 
    
一個frame包括一個local variables數組(本地變量表)，一個Operand LIFO stack和運行時常量池的一個引用。 
    

    
我們來簡單分析一下生成的字節碼指令: 
    
aload和iload指令的“a”前綴和“i”分別表示對象引用和int類型，其他還有“b”表示byte，“c”表示char，“d”表示double等等 
    
我們這里的aload_0表示將把local variable table中index 0的值push到Operand stack，iload_1類似 
    
invokespecial表示初始化對象，return表示返回 
    
sipush表示把10000這個int值push到Operand stack 
    
getstatic表示取靜態域 
    
invokevirtual表示調用一些實例方法 
    
這些指令又稱為opcode，Java一直以來只有約202個Opcode，具體請參考Java Bytecode規范。 
    

    
我們看到Test.class文件不全是二進制的指令，有些是我們可以識別的字符，這是因為有些包名、類名和常量字符串沒有編譯成二進制Bytecode指令。 
    

    
3，體驗字節碼增強的魔力 
    
我們J2EE常用的Hibernate、Spring都用到了動態字節碼修改來改變類的行為。 
    
讓我們通過看看ASM的org.objectweb.asm.MethodWriter類的部分方法來理解ASM是如何修改字節碼的: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. class MethodWriter implements MethodVisitor {   
      2. 
    
    2.   
      3. 
    
    3.     private ByteVector code = new ByteVector();   
      4. 
    
    4.   
      5. 
    
    5.     public void visitIntInsn(final int opcode, final int operand) {   
      6. 
    
    6.         // Label currentBlock = this.currentBlock;   
      7. 
    
    7.         if (currentBlock != null) {   
      8. 
    
    8.             if (compute == FRAMES) {   
      9. 
    
    9.                 currentBlock.frame.execute(opcode, operand, null, null);   
      10. 
    
    10.             } else if (opcode != Opcodes.NEWARRAY) {   
      11. 
    
    11.                 // updates current and max stack sizes only for NEWARRAY   
      12. 
    
    12.                 // (stack size variation = 0 for BIPUSH or SIPUSH)   
      13. 
    
    13.                 int size = stackSize + 1;   
      14. 
    
    14.                 if (size > maxStackSize) {   
      15. 
    
    15.                     maxStackSize = size;   
      16. 
    
    16.                 }   
      17. 
    
    17.                 stackSize = size;   
      18. 
    
    18.             }   
      19. 
    
    19.         }   
      20. 
    
    20.         // adds the instruction to the bytecode of the method   
      21. 
    
    21.         if (opcode == Opcodes.SIPUSH) {   
      22. 
    
    22.             code.put12(opcode, operand);   
      23. 
    
    23.         } else { // BIPUSH or NEWARRAY   
      24. 
    
    24.             code.put11(opcode, operand);   
      25. 
    
    25.         }   
      26. 
    
    26.     }   
      27. 
    
    27.   
      28. 
    
    28.     public void visitMethodInsn(   
      29. 
    
    29.         final int opcode,   
      30. 
    
    30.         final String owner,   
      31. 
    
    31.         final String name,   
      32. 
    
    32.         final String desc)   
      33. 
    
    33.     {   
      34. 
    
    34.         boolean itf = opcode == Opcodes.INVOKEINTERFACE;   
      35. 
    
    35.         Item i = cw.newMethodItem(owner, name, desc, itf);   
      36. 
    
    36.         int argSize = i.intVal;   
      37. 
    
    37.         // Label currentBlock = this.currentBlock;   
      38. 
    
    38.         if (currentBlock != null) {   
      39. 
    
    39.             if (compute == FRAMES) {   
      40. 
    
    40.                 currentBlock.frame.execute(opcode, 0, cw, i);   
      41. 
    
    41.             } else {   
      42. 
    
    42.                 /*  
      43. 
    
    43.                  * computes the stack size variation. In order not to recompute  
      44. 
    
    44.                  * several times this variation for the same Item, we use the  
      45. 
    
    45.                  * intVal field of this item to store this variation, once it  
      46. 
    
    46.                  * has been computed. More precisely this intVal field stores  
      47. 
    
    47.                  * the sizes of the arguments and of the return value  
      48. 
    
    48.                  * corresponding to desc.  
      49. 
    
    49.                  */  
      50. 
    
    50.                 if (argSize == 0) {   
      51. 
    
    51.                     // the above sizes have not been computed yet,   
      52. 
    
    52.                     // so we compute them...   
      53. 
    
    53.                     argSize = getArgumentsAndReturnSizes(desc);   
      54. 
    
    54.                     // ... and we save them in order   
      55. 
    
    55.                     // not to recompute them in the future   
      56. 
    
    56.                     i.intVal = argSize;   
      57. 
    
    57.                 }   
      58. 
    
    58.                 int size;   
      59. 
    
    59.                 if (opcode == Opcodes.INVOKESTATIC) {   
      60. 
    
    60.                     size = stackSize - (argSize >> 2) + (argSize & 0x03) + 1;   
      61. 
    
    61.                 } else {   
      62. 
    
    62.                     size = stackSize - (argSize >> 2) + (argSize & 0x03);   
      63. 
    
    63.                 }   
      64. 
    
    64.                 // updates current and max stack sizes   
      65. 
    
    65.                 if (size > maxStackSize) {   
      66. 
    
    66.                     maxStackSize = size;   
      67. 
    
    67.                 }   
      68. 
    
    68.                 stackSize = size;   
      69. 
    
    69.             }   
      70. 
    
    70.         }   
      71. 
    
    71.         // adds the instruction to the bytecode of the method   
      72. 
    
    72.         if (itf) {   
      73. 
    
    73.             if (argSize == 0) {   
      74. 
    
    74.                 argSize = getArgumentsAndReturnSizes(desc);   
      75. 
    
    75.                 i.intVal = argSize;   
      76. 
    
    76.             }   
      77. 
    
    77.             code.put12(Opcodes.INVOKEINTERFACE, i.index).put11(argSize >> 2, 0);   
      78. 
    
    78.         } else {   
      79. 
    
    79.             code.put12(opcode, i.index);   
      80. 
    
    80.         }   
      81. 
    
    81.     }   
      82. 
    
    82. }  
      83. 

    

    


    
通過注釋我們可以大概理解visitIntInsn和visitMethodInsn方法的意思。 
    
比如visitIntInsn先計算stack的size，然后根據opcode來判斷是SIPUSH指令還是BIPUSH or NEWARRAY指令，并相應的調用字節碼修改相關的方法。 
    

    

    
三、ASM 
    
我們知道Java是靜態語言，而python、ruby是動態語言，Java程序一旦寫好很難在運行時更改類的行為，而python、ruby可以。 
    
不過基于bytecode層面上我們可以做一些手腳，來使Java程序多一些靈活性和Magic，ASM就是這樣一個應用廣泛的開源庫。 
    

    
ASM is a Java bytecode manipulation framework. It can be used to dynamically generate stub classes or other proxy classes, 
    
directly in binary form, or to dynamically modify classes at load time, i.e., just before they are loaded into the Java 
    
Virtual Machine. 
    

    
ASM完成了BCEL和SERP同樣的功能，但ASM 
    
只有30多k，而后兩者分別是350k和150k。apache真是越來越過氣了。 
    

    
讓我們來看一個ASM的簡單例子Helloworld.java，它生成一個Example類和一個main方法，main方法打印"Hello world!"語句: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. import java.io.FileOutputStream;   
      2. 
    
    2. import java.io.PrintStream;   
      3. 
    
    3.   
      4. 
    
    4. import org.objectweb.asm.ClassWriter;   
      5. 
    
    5. import org.objectweb.asm.MethodVisitor;   
      6. 
    
    6. import org.objectweb.asm.Opcodes;   
      7. 
    
    7. import org.objectweb.asm.Type;   
      8. 
    
    8. import org.objectweb.asm.commons.GeneratorAdapter;   
      9. 
    
    9. import org.objectweb.asm.commons.Method;   
      10. 
    
    10.   
      11. 
    
    11. public class Helloworld extends ClassLoader implements Opcodes {   
      12. 
    
    12.   
      13. 
    
    13.   public static void main(final String args[]) throws Exception {   
      14. 
    
    14.   
      15. 
    
    15.     // creates a ClassWriter for the Example public class,   
      16. 
    
    16.     // which inherits from Object   
      17. 
    
    17.   
      18. 
    
    18.     ClassWriter cw = new ClassWriter(0);   
      19. 
    
    19.     cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);   
      20. 
    
    20.     MethodVisitor mw = cw.visitMethod(ACC_PUBLIC, "<init>", "()V", null,   
      21. 
    
    21.         null);   
      22. 
    
    22.     mw.visitVarInsn(ALOAD, 0);   
      23. 
    
    23.     mw.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "<init>", "()V");   
      24. 
    
    24.     mw.visitInsn(RETURN);   
      25. 
    
    25.     mw.visitMaxs(1, 1);   
      26. 
    
    26.     mw.visitEnd();   
      27. 
    
    27.     mw = cw.visitMethod(ACC_PUBLIC + ACC_STATIC, "main",   
      28. 
    
    28.         "([Ljava/lang/String;)V", null, null);   
      29. 
    
    29.     mw.visitFieldInsn(GETSTATIC, "java/lang/System", "out",   
      30. 
    
    30.         "Ljava/io/PrintStream;");   
      31. 
    
    31.     mw.visitLdcInsn("Hello world!");   
      32. 
    
    32.     mw.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println",   
      33. 
    
    33.         "(Ljava/lang/String;)V");   
      34. 
    
    34.     mw.visitInsn(RETURN);   
      35. 
    
    35.     mw.visitMaxs(2, 2);   
      36. 
    
    36.     mw.visitEnd();   
      37. 
    
    37.     byte[] code = cw.toByteArray();   
      38. 
    
    38.     FileOutputStream fos = new FileOutputStream("Example.class");   
      39. 
    
    39.     fos.write(code);   
      40. 
    
    40.     fos.close();   
      41. 
    
    41.     Helloworld loader = new Helloworld();   
      42. 
    
    42.     Class exampleClass = loader   
      43. 
    
    43.         .defineClass("Example", code, 0, code.length);   
      44. 
    
    44.     exampleClass.getMethods()[0].invoke(null, new Object[] { null });   
      45. 
    
    45.   
      46. 
    
    46.     // ------------------------------------------------------------------------   
      47. 
    
    47.     // Same example with a GeneratorAdapter (more convenient but slower)   
      48. 
    
    48.     // ------------------------------------------------------------------------   
      49. 
    
    49.   
      50. 
    
    50.     cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);   
      51. 
    
    51.     cw.visit(V1_1, ACC_PUBLIC, "Example", null, "java/lang/Object", null);   
      52. 
    
    52.     Method m = Method.getMethod("void <init> ()");   
      53. 
    
    53.     GeneratorAdapter mg = new GeneratorAdapter(ACC_PUBLIC, m, null, null,   
      54. 
    
    54.         cw);   
      55. 
    
    55.     mg.loadThis();   
      56. 
    
    56.     mg.invokeConstructor(Type.getType(Object.class), m);   
      57. 
    
    57.     mg.returnValue();   
      58. 
    
    58.     mg.endMethod();   
      59. 
    
    59.     m = Method.getMethod("void main (String[])");   
      60. 
    
    60.     mg = new GeneratorAdapter(ACC_PUBLIC + ACC_STATIC, m, null, null, cw);   
      61. 
    
    61.     mg.getStatic(Type.getType(System.class), "out", Type   
      62. 
    
    62.         .getType(PrintStream.class));   
      63. 
    
    63.     mg.push("Hello world!");   
      64. 
    
    64.     mg.invokeVirtual(Type.getType(PrintStream.class), Method   
      65. 
    
    65.         .getMethod("void println (String)"));   
      66. 
    
    66.     mg.returnValue();   
      67. 
    
    67.     mg.endMethod();   
      68. 
    
    68.     cw.visitEnd();   
      69. 
    
    69.     code = cw.toByteArray();   
      70. 
    
    70.     loader = new Helloworld();   
      71. 
    
    71.     exampleClass = loader.defineClass("Example", code, 0, code.length);   
      72. 
    
    72.     exampleClass.getMethods()[0].invoke(null, new Object[] { null });   
      73. 
    
    73.   }   
      74. 
    
    74. }  
      75. 

    

    


    
我們看到上面的例子分別使用ASM的MethodVisitor和GeneratorAdapter兩種方式來動態生成Example類并調用打印語句。 
    

    
四、cglib 
    
cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime. 
    
cglib是Code Generation Library的縮寫。 
    
cglib依賴于ASM庫。 
    
Hibernate主要是利用cglib生成pojo的子類并override get方法來實現lazy loading機制，Spring則是利用cglib來實現動態代理。 
    
而JDK的動態代理機制要求有接口才行，這樣就強制我們的pojo實現某個接口。 
    

    
這里還是提供一個cglib的入門級的示例: 
    
MyClass.java: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. public class MyClass {   
      2. 
    
    2.   
      3. 
    
    3.   public void print() {   
      4. 
    
    4.     System.out.println("I'm in MyClass.print!");   
      5. 
    
    5.   }   
      6. 
    
    6.   
      7. 
    
    7. }  
      8. 

    

    


    
Main.java: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. import java.lang.reflect.Method;   
      2. 
    
    2. import net.sf.cglib.proxy.Enhancer;   
      3. 
    
    3. import net.sf.cglib.proxy.MethodInterceptor;   
      4. 
    
    4. import net.sf.cglib.proxy.MethodProxy;   
      5. 
    
    5.   
      6. 
    
    6. public class Main {   
      7. 
    
    7.   
      8. 
    
    8.   public static void main(String[] args) {   
      9. 
    
    9.   
      10. 
    
    10.     Enhancer enhancer = new Enhancer();   
      11. 
    
    11.     enhancer.setSuperclass(MyClass.class);   
      12. 
    
    12.     enhancer.setCallback(new MethodInterceptorImpl());   
      13. 
    
    13.     MyClass my = (MyClass) enhancer.create();   
      14. 
    
    14.     my.print();   
      15. 
    
    15.   }   
      16. 
    
    16.   
      17. 
    
    17.   private static class MethodInterceptorImpl implements MethodInterceptor {   
      18. 
    
    18.     public Object intercept(Object obj, Method method, Object[] args,   
      19. 
    
    19.         MethodProxy proxy) throws Throwable {   
      20. 
    
    20.       // log something   
      21. 
    
    21.       System.out.println(method + " intercepted!");   
      22. 
    
    22.   
      23. 
    
    23.       proxy.invokeSuper(obj, args);   
      24. 
    
    24.       return null;   
      25. 
    
    25.     }   
      26. 
    
    26.   }   
      27. 
    
    27. }  
      28. 

    

    


    
打印結果為: 
    

    

    

    Java代碼 復制代碼
    

    

      
    
    1. public void MyClass.print() intercepted!   
      2. 
    
    2. I'm in MyClass.print!  
      3. 

    

    


    
這個示例就基本上實現了日志AOP的功能，很簡單吧。 
    

    
參考資料 
    
CLR和JRE的運行機制的初步總結 
    
Java虛擬機 
    
了解Java ClassLoader 
    
Java Virtual Machine Specification 
    
Java bytecode 
    
解讀字節碼文件 
    
Java Bytecode Specification and Verification 
    
ASM User Guide 
    
Hello, ASM 
    
cglig指南 
    
Java下的框架編程--cglib的應用 
    
AOP = Proxy Pattern + Method Reflection + Aspect DSL + 自動代碼生成 
    
深入淺出Spring AOP 
    

    
Traceback:http://www.javaeye.com/topic/98178

		
    
			posted on 2009-04-14 09:22 YXY 閱讀(315) 評論(0)  編輯  收藏  
		
    
	
    
	
	





    
	    
    




    





    


    

	
    
		
    
				
		
	
		
    
		
		
    只有注冊用戶登錄后才能發表評論。
    
		
    
			
		
    
			
		
    
		
		
    
		


    

		    		
		
    
		
    			
		
		
		
		
    
		
    
		
		
    
		
    
			網站導航:
		
		
    
		
    
			
		
    	
		
    
			 
		
    
		
    
			
		
    
		
    
			
				
		
    		
	
    	

    



    

				

    



    







    
        
	



主站蜘蛛池模板：
亚洲精品无码专区久久久|
亚洲AⅤ优女AV综合久久久|
久久久久亚洲精品成人网小说|
一级做a爱过程免费视|
久99精品视频在线观看婷亚洲片国产一区一级在线|
自拍偷区亚洲国内自拍|
我要看免费的毛片|
亚洲熟妇少妇任你躁在线观看|
中文字幕人成无码免费视频
|
一级做a爰片性色毛片免费网站
|
亚洲中文字幕无码中文字在线|
色婷婷综合缴情综免费观看|
国产亚洲情侣一区二区无|
一个人看的在线免费视频|
亚洲中文字幕无码久久精品1|
A级毛片成人网站免费看|
亚洲AV无码一区二区三区DV|
日韩av无码久久精品免费|
亚洲色欲色欲综合网站|
69式国产真人免费视频|
国内精品久久久久影院亚洲|
国产免费看插插插视频|
黄色视频在线免费观看|
亚洲国产人成在线观看69网站
|
久久精品免费网站网|
亚洲爆乳无码专区|
精品女同一区二区三区免费站|
午夜在线a亚洲v天堂网2019|
国产麻豆免费观看91|
国产免费人成视频尤勿视频|
亚洲人成在线电影|
成人人免费夜夜视频观看|
亚洲免费一区二区|
久久亚洲sm情趣捆绑调教|
日美韩电影免费看|
91视频免费观看|
亚洲性线免费观看视频成熟|
亚洲精品色婷婷在线影院|
99ee6热久久免费精品6|
看亚洲a级一级毛片|
亚洲国产国产综合一区首页|