程序博客网 > 网易电台录制软件

设计模式学习---第三节：代理模式

来源：互联网 发布：网易电台录制软件 编辑：程序博客网 时间：2024/06/01 08:34

代理模式有几种，虚拟代理，计数代理，远程代理，动态代理。主要分为两类，静态代理和动态代理。


静态代理

--在程序运行前就编译好的，而不是由程序动态产生代理类


静态代理模式其实很常见，比如买火车票这件小事：黄牛相当于是火车站的代理，我们可以通过黄牛买票，但只能去火车站进行改签和退票。在代码实现中相当于为一个委托对象realSubject提供一个代理对象proxy，通过proxy可以调用realSubject的部分功能，并添加一些额外的业务处理，同时可以屏蔽realSubject中未开放的接口。


 

1、RealSubject 真实主题角色，是实现抽象主题接口的类;

2、Proxy 是代理类,内部含有对真实对象RealSubject的引用，从而可以操作真实对象。

3、Subject 抽象主题角色，是一个接口。该接口是对象和它的代理共用的接口;

4、request() 是委托类和代理类的共同方法；

具体代码实现如下：

interface Subject {    void request();}class RealSubject implements Subject {    public void request(){        System.out.println("RealSubject");    }}class Proxy implements Subject {    private Subject subject;    public Proxy(Subject subject){        this.subject = subject;    }    public void request(){        System.out.println("begin");        subject.request();        System.out.println("end");    }}public class ProxyTest {    public static void main(String args[]) {        RealSubject subject = new RealSubject();        Proxy p = new Proxy(subject);        p.request();    }}

静态代理实现中，一个委托类对应一个代理类，代理类在编译期间就已经确定。

动态代理

--实现动态代理的关键技术是反射。

动态代理中，代理类并不是在Java代码中实现，而是在运行时期生成，相比静态代理，动态代理可以很方便的对委托类的方法进行统一处理，如添加方法调用次数、添加日志功能等等，动态代理分为jdk动态代理和cglib动态代理，下面通过一个例子看看如何实现jdk动态代理。

JDK动态代理

jdk动态代理使用的局限性通过反射类Proxy和InvocationHandler回调接口实现的jdk动态代理，要求委托类必须实现一个接口，但事实上并不是所有类都有接口，对于没有实现接口的类，便无法使用该方方式实现动态代理。

1、定义业务逻辑

public interface Service {      //目标方法     public abstract void add();  } public class UserServiceImpl implements Service {      public void add() {          System.out.println("This is add service");      }  }

2、利用java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口定义代理类的实现。

class MyInvocatioHandler implements InvocationHandler {    private Object target;    public MyInvocatioHandler(Object target) {        this.target = target;    }    @Override    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {        System.out.println("-----before-----");        Object result = method.invoke(target, args);        System.out.println("-----end-----");        return result;    }    // 生成代理对象    public Object getProxy() {        ClassLoader loader = Thread.currentThread().getContextClassLoader();        Class<?>[] interfaces = target.getClass().getInterfaces();        return Proxy.newProxyInstance(loader, interfaces, this);    }}

3、使用动态代理

public class ProxyTest {    public static void main(String[] args) {        Service service = new UserServiceImpl();        MyInvocatioHandler handler = new MyInvocatioHandler(service);        Service serviceProxy = (Service)handler.getProxy();        serviceProxy.add();    }}

执行结果：

-----before-----This is add service-----end-----

代理对象的生成过程由Proxy类的newProxyInstance方法实现，分为3个步骤：


1、ProxyGenerator.generateProxyClass方法负责生成代理类的字节码，生成逻辑比较复杂，有兴趣的同学可以继续分析源码 sun.misc.ProxyGenerator；

// proxyName：格式如 "com.sun.proxy.$Proxy.1"；// interfaces：代理类需要实现的接口数组；// accessFlags：代理类的访问标识；byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);

2、native方法Proxy.defineClass0负责字节码加载的实现，并返回对应的Class对象。

Class clazz = defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);

3、利用clazz.newInstance反射机制生成代理类的对象；


反编译代理类
为了更清楚的理解动态代理，通过以下方式把代理类字节码生成class文件。

byte[] classFile = ProxyGenerator.generateProxyClass("com.sun.proxy.$Proxy.1", service.getClass().getInterfaces());FileOutputStream out = new FileOutputStream("com.sun.proxy.$Proxy.1.class");out.write(classFile);out.flush();

使用 反编译工具 jad jad com.sun.proxy.$Proxy.1 看看代理类如何实现，反编译出来的java代码如下：

public final class $proxy1 extends Proxy implements Service {    public $proxy1(InvocationHandler invocationhandler) {        super(invocationhandler);    }    public final boolean equals(Object obj) {        try {            return ((Boolean)super.h.invoke(this, m1, new Object[] {                obj            })).booleanValue();        }        catch(Error _ex) { }        catch(Throwable throwable) {            throw new UndeclaredThrowableException(throwable);        }    }    public final String toString() {        try {            return (String)super.h.invoke(this, m2, null);        }        catch(Error _ex) { }        catch(Throwable throwable) {            throw new UndeclaredThrowableException(throwable);        }    }    public final void add() {        try {            super.h.invoke(this, m3, null);            return;        }        catch(Error _ex) { }        catch(Throwable throwable) {            throw new UndeclaredThrowableException(throwable);        }    }    public final int hashCode() {        try {            return ((Integer)super.h.invoke(this, m0, null)).intValue();        }        catch(Error _ex) { }        catch(Throwable throwable) {            throw new UndeclaredThrowableException(throwable);        }    }    private static Method m1;    private static Method m2;    private static Method m3;    private static Method m0;    static {        try {            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {                Class.forName("java.lang.Object")            });            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);            m3 = Class.forName("zzzzzz.Service").getMethod("add", new Class[0]);            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);        }        catch(NoSuchMethodException nosuchmethodexception) {            throw new NoSuchMethodError(nosuchmethodexception.getMessage());        }        catch(ClassNotFoundException classnotfoundexception) {            throw new NoClassDefFoundError(classnotfoundexception.getMessage());        }    }}

从上述代码可以发现：
1、生成的$proxy1继承自Proxy类，并实现了Service接口。
2、执行代理对象的方法，其实就是执行InvocationHandle对象的invoke方法，传入的参数分别是当前代理对象，当前执行的方法和参数。

super.h.invoke(this, m3, null);
JDK动态代理步骤
1.       创建一个实现InvocationHandler接口的类，它必须实现invoke()方法
2.       创建被代理的类及接口
3.       调用Proxy的静态方法，创建一个代理类
4.       通过代理调用方法
而为什么要进行如此操作，可以从Proxy和InvocationHandler的源码中找打答案。对源码不感兴趣的可以将下面的源码部分小节略过。
JDK动态代理原理与源码
newProxyInstance()方法的源码：
[java] view plain copy
  1.     public static Object newProxyInstance(ClassLoader loader,  
  2.                                          Class<?>[] interfaces,  
  3.                                          InvocationHandler h)  
  4.         throws IllegalArgumentException{  
  5.         if (h == null) {  
  6.             throw new NullPointerException();  
  7.         }  
  8.         final Class<?>[] intfs = interfaces.clone();  
  9.         final SecurityManager sm = System.getSecurityManager();  
  10.         if (sm != null) {  
  11.             checkProxyAccess(Reflection.getCallerClass(), loader, intfs);  
  12.         }  
  13.         /*查找或生成指定的代理类*/  
  14.         Class<?> cl = getProxyClass0(loader, intfs);  
  15.         /*用指定的调用处理程序调用它的构造函数.*/  
  16.         try {  
  17.         //获得类的构造函数  
  18.             final Constructor<?> cons =cl.getConstructor(constructorParams);  
  19.             final InvocationHandler ih = h;  
  20.             if (sm != null && ProxyAccessHelper.needsNewInstanceCheck(cl)) {  
  21.               //当需要代理的类实现了一个非public的接口时，因为这样的接口需要特殊的权限，因此调用doPrivilege（native 修饰的方法）创建代理实例。  
  22.                 return AccessController.doPrivileged(newPrivilegedAction<Object>() {  
  23.                     public Object run() {  
  24.                         return newInstance(cons,ih);  
  25.                     }  
  26.                 });  
  27.             } else {  
  28.                 return newInstance(cons,ih);  
  29.             }  
  30.         } catch (NoSuchMethodException e) {  
  31.             throw new InternalError(e.toString());  
  32.         }  
  33. }  
可以看到，获得代理类的代码是
Class<?>cl = getProxyClass0(loader,intfs);
并由此获得代理类的构造函数，生成代理类的实例返回给该方法的调用者。
继续跟进getProxyClass0()方法：
[java] view plain copy
  1. /** 生成代理类。调用该方法前必须使用checkproxyaccess方法执行权限检查。*/  
  2.     private static Class<?> getProxyClass0(ClassLoader loader,  
  3.                                           Class<?>... interfaces) {  
  4.     //检查实现的接口数，65535这个数字好特殊，端口数好像也是这个，这个数字是由虚拟机所决定的，2^16-1个  
  5.     if (interfaces.length > 65535) {  
  6.             throw new IllegalArgumentException("interface limit exceeded");  
  7.         }  
  8.         // 如果代理类已经通过实现给定接口的类加载器创建了，则返回缓存中的该类的副本；否则将通过ProxyClassFactory创建代理类  
  9.         return proxyClassCache.get(loader, interfaces);  
  10. }  
还是没有看到代理类是怎么生成的，只知道代理类是从proxyClassCache中取得的，这个变量是与缓存相关的一个对象，查看该变量的声明与初始化：
[java] view plain copy
  1. private static final WeakCache<ClassLoader, Class<?>[], Class<?>>  
  2.         proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());  
可以发现proxyClassCache是个用来缓存代理类的类变量，大家知道类变量的特点是与类一一对应，在一个虚拟机中类只有一个，对应着在一个虚拟机中类变量也只有一个，且在此处，在Proxy类被加载的时候就赋值了。在赋值操作的参数中有ProxyClassFactory()这么一个构造函数，这个是动态代理中的关键：生成代理类的类文件字节码。继续跟进去，找到代理类的生成之处了：
[java] view plain copy
  1. /** 根据给定的类加载器和接口数组生成代理类的工厂类*/  
  2. private static final class ProxyClassFactory  
  3.     implements BiFunction<ClassLoader,Class<?>[], Class<?>>  
  4. {  
  5.     // 所有代理类名称的前缀  
  6.     private static final String proxyClassNamePrefix = "$Proxy";  
  7.   
  8.     //用于生成唯一代理类名称的下一个序号  
  9.     private static final AtomicLong nextUniqueNumber = new AtomicLong();  
  10.   
  11.     @Override  
  12.     public Class<?> apply(ClassLoader loader,Class<?>[] interfaces) {  
  13.   
  14.         Map<Class<?>, Boolean>interfaceSet = new IdentityHashMap<>(interfaces.length);  
  15.         for (Class<?> intf : interfaces) {  
  16.             /* 验证类加载器将此接口的名称解析为实际对象的名称。*/  
  17.             Class<?> interfaceClass =null;  
  18.             try {  
  19.                 interfaceClass = Class.forName(intf.getName(),false, loader);  
  20.             } catch (ClassNotFoundException e) {  
  21.             }  
  22.             if (interfaceClass != intf) {  
  23.                 throw new IllegalArgumentException(  
  24.                     intf + " is not visible from classloader");  
  25.             }  
  26.             /* 验证类对象确实是一个接口。*/  
  27.             if (!interfaceClass.isInterface()) {  
  28.                 throw new IllegalArgumentException(  
  29.                    interfaceClass.getName() + " is not an interface");  
  30.             }  
  31.             /*确保接口唯一*/  
  32.             if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {  
  33.                 throw new IllegalArgumentException(  
  34.                     "repeated interface: " + interfaceClass.getName());  
  35.             }  
  36.         }  
  37.   
  38.         String proxyPkg = null;     // 代理类的包名  
  39.   
  40.         /*记录非公开代理接口的包，以便将代理类定义在同一个包中。确认所有非公共代理接口都在同一个包中。*/  
  41.         for (Class<?> intf : interfaces) {  
  42.             int flags = intf.getModifiers();  
  43.             if (!Modifier.isPublic(flags)) {  
  44.                 String name =intf.getName();  
  45.                 int n = name.lastIndexOf('.');  
  46.                 String pkg = ((n == -1) ? "" : name.substring(0, n + 1));  
  47.                 if (proxyPkg == null) {  
  48.                     proxyPkg = pkg;  
  49.                 } else if (!pkg.equals(proxyPkg)) {  
  50.                     throw new IllegalArgumentException(  
  51.                         "non-public interfaces fromdifferent packages");  
  52.                 }  
  53.             }  
  54.         }  
  55.   
  56.         if (proxyPkg == null) {  
  57.             // 如果没有非公开的代理接口，使用com.sun.proxy作为包名  
  58.             proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";  
  59.         }  
  60.   
  61.         /* 生成代理类名的序号*/  
  62.         long num = nextUniqueNumber.getAndIncrement();  
  63.         //生成全类名  
  64.         String proxyName = proxyPkg + proxyClassNamePrefix + num;  
  65.   
  66.         /*生成代理类字节码 */  
  67.         byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName,interfaces);  
  68.         try {  
  69.             return defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);  
  70.         } catch (ClassFormatError e) {  
  71.             throw new IllegalArgumentException(e.toString());  
  72.         }  
  73.     }  
在ProxyClassFactory中，可以看到产生代理类的具体逻辑，大致上是，根据传递的被代理类及其实现的接口生成代理类的字节码加载到缓存中，但是加载到缓存中只是一个.java文件也不能用，所以底层还有编译等操作。到这里，可以大致的看清JDK中动态代理的面孔了，实现的步骤为：
1.      创建代理类的源码；
2.      对源码进行编译成字节码；
3.      将字节码加载到内存；
4.      实例化代理类对象并返回给调用者；
底层的代码我们看不到，但是我们可以查看其生成的字节码：
[java] view plain copy
  1. //获得字节码的测试方法  
  2.     byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy1", Car.class.getInterfaces());   
  3.         FileOutputStream out = null;   
  4.         try {   
  5.             out = new FileOutputStream(System.getProperty("user.dir") + "\\$Proxy1.class");   
  6.             out.write(classFile);   
  7.             out.flush();   
  8.         } catch (Exception e) {   
  9.             e.printStackTrace();   
  10.         } finally {   
  11.             try {   
  12.                 out.close();   
  13.             } catch (IOException e) {   
  14.                 e.printStackTrace();   
  15.             }   
  16.         }  
  17.    
  18. //生成的字节码：  
  19. importcn.com.goser.proxy.imooc.staticproxy.Moveable;  
  20. importjava.lang.reflect.InvocationHandler;  
  21. importjava.lang.reflect.Method;  
  22. importjava.lang.reflect.Proxy;  
  23. import java.lang.reflect.UndeclaredThrowableException;  
  24.    
  25. public final class $Proxy1 extends Proxy  
  26.   implements Moveable  
  27. {  
  28.   private static Method m1;  
  29.   private static Method m3;  
  30.   private static Method m0;  
  31.   private static Method m2;  
  32.    
  33.   public $Proxy1(InvocationHandler paramInvocationHandler)  
  34.     throws  
  35.   {  
  36.     super(paramInvocationHandler);  
  37.   }  
  38.    
  39.   public final boolean equals(Object paramObject)  
  40.     throws  
  41.   {  
  42.     try  
  43.     {  
  44.       return ((Boolean)this.h.invoke(this, m1, new Object[] { paramObject })).booleanValue();  
  45.     }  
  46.     catch (RuntimeException localRuntimeException)  
  47.     {  
  48.       throw localRuntimeException;  
  49.     }  
  50.     catch (Throwable localThrowable)  
  51.     {  
  52.     }  
  53.     throw new UndeclaredThrowableException(localThrowable);  
  54.   }  
  55.    
  56.   public final void move()  
  57.     throws Exception  
  58.   {  
  59.     try  
  60.     {  
  61.       this.h.invoke(this, m3, null);  
  62.       return;  
  63.     }  
  64.     catch (Exception localException)  
  65.     {  
  66.       throw localException;  
  67.     }  
  68.     catch (Throwable localThrowable)  
  69.     {  
  70.     }  
  71.     throw new UndeclaredThrowableException(localThrowable);  
  72.   }  
  73.    
  74.   public final int hashCode()  
  75.     throws  
  76.   {  
  77.     try  
  78.     {  
  79.       return ((Integer)this.h.invoke(this, m0, null)).intValue();  
  80.     }  
  81.     catch (RuntimeException localRuntimeException)  
  82.     {  
  83.       throw localRuntimeException;  
  84.     }  
  85.     catch (Throwable localThrowable)  
  86.     {  
  87.     }  
  88.     throw new UndeclaredThrowableException(localThrowable);  
  89.   }  
  90.    
  91.   public final String toString()  
  92.     throws  
  93.   {  
  94.     try  
  95.     {  
  96.       return (String)this.h.invoke(this, m2, null);  
  97.     }  
  98.     catch (RuntimeException localRuntimeException)  
  99.     {  
  100.       throw localRuntimeException;  
  101.     }  
  102.     catch (Throwable localThrowable)  
  103.     {  
  104.     }  
  105.     throw new UndeclaredThrowableException(localThrowable);  
  106.   }  
  107.    
  108.   static  
  109.   {  
  110.     try  
  111.     {  
  112.       m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] { Class.forName("java.lang.Object") });  
  113.       m3 = Class.forName("cn.com.goser.proxy.imooc.staticproxy.Moveable").getMethod("move", new Class[0]);  
  114.       m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);  
  115.       m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);  
  116.       return;  
  117.     }  
  118.     catch (NoSuchMethodExceptionlocalNoSuchMethodException)  
  119.     {  
  120.       throw new NoSuchMethodError(localNoSuchMethodException.getMessage());  
  121.     }  
  122.     catch (ClassNotFoundExceptionlocalClassNotFoundException)  
  123.     {  
  124.     }  
  125.     throw new NoClassDefFoundError(localClassNotFoundException.getMessage());  
  126.   }  
  127. }  
生成的字节码比较长，但是在字节码中最关键的信息是代理类的声明：
public final class $Proxy1 extends Proxy
可以看到生成的代理类是继承了Proxy类的，这就是说明了为什么使用JDK动态代理不能实现继承式动态代理，原因是Java不允许多继承，而生成的代理类本身就已经继承了Proxy类。
至此，JDK的动态代理的使用及底层原理分析完毕，揭下动态代理的神秘面纱，果然是枚美女。
至于最底层的native方法是怎么动态生成代理类的字节码我们也可以简单的模拟一下，先分析下模拟的步骤：首先要生成一段代理类的源码，然后将源码编译后生成代理类的实例返回给调用者。依据此步骤开始编写我们的模拟代码：
[java] view plain copy
  1. /** 
  2.  * JDK java.lang.reflect.Proxy的模拟 
  3.  * @author Goser    (mailto:goskalrie@163.com) 
  4.  * @Since 2016年9月7日 
  5.  */  
  6. public class Proxy {  
  7.     private static final String  RT = "\r\n";  
  8.     public static Object newProxyInstance() throws Exception{  
  9.         //声明一段源码  
  10.         String sourceCode =  
  11.         "packagecn.com.goser.proxy.jdk.simulate;"+ RT +  
  12.         "importcn.com.goser.proxy.imooc.staticproxy.Admin;" + RT +  
  13.         "importcn.com.goser.proxy.imooc.staticproxy.Manager;" + RT +  
  14.         "//以聚合方式实现的代理主题" + RT +  
  15.         "public class $Proxy0 implementsManager{" + RT +  
  16.         "   privateAdmin admin;" + RT +  
  17.         "   public$Proxy0(Admin admin) {" + RT +  
  18.         "       super();" + RT +  
  19.         "       this.admin= admin;" + RT +  
  20.         "   }" + RT +  
  21.         "   publicvoid doSomething() {" + RT +  
  22.         "       System.out.println(\"Log:admin操作开始\");" + RT +  
  23.         "       admin.doSomething();" + RT +  
  24.         "       System.out.println(\"Log:admin操作结束\");" + RT +  
  25.         "   }" + RT +  
  26.         "}";  
  27.         String filename = System.getProperty("user.dir") + "/src/main/java/cn/com/goser/proxy/jdk/simulate/$Proxy0.java";  
  28.         File file = new File(filename);  
  29.         //使用org.apache.commons.io.FileUtils.writeStringToFile()将源码写入磁盘  
  30.         //编写到处，可以运行一下程序，可以在当前目录中看到生成的.java文件  
  31.         FileUtils.writeStringToFile(file,sourceCode);  
  32.         //获得当前系统中的编译器  
  33.         JavaCompiler complier = ToolProvider.getSystemJavaCompiler();  
  34.         //获得文件管理者  
  35.         StandardJavaFileManager fileMgr =complier.getStandardFileManager(null, null, null);  
  36.         Iterable its =fileMgr.getJavaFileObjects(filename);  
  37.         //编译任务  
  38.         CompilationTask task = complier.getTask(null, fileMgr, null, null, null, its);  
  39.         //开始编译，执行完可在当前目录下看到.class文件  
  40.         task.call();  
  41.         fileMgr.close();  
  42.         //load到内存  
  43.         ClassLoader loader = ClassLoader.getSystemClassLoader();  
  44.         Class cls = loader.loadClass("cn.com.goser.proxy.jdk.simulate.$Proxy0");  
  45.         //生成代理类对象  
  46.         Constructor ct = cls.getConstructor(Admin.class);  
  47.         return ct.newInstance(new Admin());  
  48.     }  
  49. }  
  50. class test{  
  51.     public static void main(String[] args) throws Exception {  
  52.         Manager m = (Manager)Proxy.newProxyInstance();  
  53.         m.doSomething();  
  54.     }  
  55. }  
运行测试代码，结果和手工编写的结果一致，完成了JDK中动态代理的实现模拟。
cglib动态代理
前面分析到，因为Java只允许单继承，而JDK生成的代理类本身就继承了Proxy类，因此，使用JDK实现的动态代理不能完成继承式的动态代理，但是我们可以使用cglib来实现继承式的动态代理。
大名鼎鼎的Spring中就含有cglib动态代理，在此也以Spring中自带的cglib完成动态代理的实现：
[java] view plain copy
  1. //1.具体主题  
  2. public class Train{  
  3.     public void move(){  
  4.         System.out.println("火车行驶中…");  
  5.     }  
  6. }  
  7. //2.生成代理  
  8. public class CGLibProxy implements MethodInterceptor {  
  9.     private Enhancer enhancer = new Enhancer();  
  10.     public Object getProxy(Class<?> clazz){  
  11.         enhancer.setSuperclass(clazz);  
  12.         enhancer.setCallback(this);  
  13.         return enhancer.create();  
  14.     }  
  15.     /** 
  16.      * 拦截所有目标类方法的调用 
  17.      * 参数： 
  18.      * obj目标实例对象 
  19.      *method 目标方法的反射对象 
  20.      * args方法的参数 
  21.      * proxy代理类的实例 
  22.      */  
  23.     public Object intercept(Object obj, Method method, Object[] args,  
  24.             MethodProxy proxy) throws Throwable {  
  25.         //代理类调用父类的方法  
  26.         System.out.println("日志开始");  
  27.         proxy.invokeSuper(obj, args);  
  28.         System.out.println("日志结束");  
  29.         return null;  
  30.     }  
  31. }  
  32. //3.测试  
  33. public class Test {  
  34.     public static void main(String[] args) {  
  35.         CGLibProxy proxy = new CGLibProxy();  
  36.         Train t = (Train) proxy.getProxy(Train.class);  
  37.         t.move();  
  38.     }  
  39. }  




阅读全文
0 0
网易电台录制软件 网易电台录制软件
原创粉丝点击
热门IT博客
美国的华莱士 知乎美国的华莱士 知乎
做特效的软件做特效的软件
淘宝店铺 ip地址
godaddy域名邮箱设置
中国男乒全军覆没 知乎
js style.marginleft
王军税务总局调离知乎
java接收http请求
mac口红a17是什么颜色
人工智能论文话题英文
政务大数据开放平台
淘宝贷款怎么申请不了
为什么淘宝联盟登不上
淘宝超级店长在哪里
名不虚传软件
工字钢简支梁计算软件
java单元测试用例
leveldb源码分析
网络技术管理
java 接收app上传图片
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 打造诸天第一圣地 广州网红打卡圣地 世界七大恐怖圣地 南宁网红拍照圣地 三国群英传7练级圣地 遗落圣坛 圣坛 遗落圣坛水晶柱怎么点亮2019 遗落圣坛隐藏冈布奥 遗落圣坛水晶柱 遗落圣坛速刷 遗落圣坛dp攻略 遗落圣坛点亮水晶柱 遗落圣坛铁三角速刷 遗落圣坛平民打法 遗落圣坛什么组合速刷快 曲阜师范大学圣坛学院 不思议迷宫遗落圣坛攻略 不思议迷宫遗落圣坛水晶柱 不思议迷宫遗落圣坛 不思议迷宫元素圣坛 不思议迷宫遗落圣坛dp攻略 不可思议迷宫元素圣坛 二郎神7分钟速刷遗落圣坛 圣城风云 圣城家园 圣城 圣城网 圣城家园影视 基督教圣城网 曲阜圣城宾馆 圣城家园 影视天堂 耶路撒冷为什么是圣城 圣域 学校的圣域 圣域3 圣域2 圣域战尊 圣域之门 神魔圣域 圣域2黄金版

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里