精华内容
下载资源
问答
  • 举例说明java动态代理

    2020-06-28 15:37:46
    代理模式是为其他对象提供一个代理以控制对某个对象的访问,代理类主要负责为委托了(真实对象)预处理消息、过滤消息、传递消息给委托类,代理类不现实具体服务,而是利用委托类来完成服务,并将执行结果封装处理。...

    1 什么是代理模式

    代理模式是为其他对象提供一个代理以控制对某个对象的访问,代理类主要负责为委托了(真实对象)预处理消息、过滤消息、传递消息给委托类,代理类不现实具体服务,而是利用委托类来完成服务,并将执行结果封装处理。
    其实就是相当于明星与经纪人的关系,明星就是被代理类,经纪人是代理类,经纪人处理除了表演外的其他辅助工作,需要表演时调用明星的表演方法。
    其实就是代理类为被代理类预处理消息、过滤消息并在此之后将消息转发给被代理类,之后还能进行消息的后置处理。代理类和被代理类通常会存在关联关系(即上面提到的持有的被带离对象的引用),代理类本身不实现服务,而是通过调用被代理类中的方法来提供服务。

    2 静态代理

    创建一个接口,然后创建被代理的类实现该接口并且实现该接口中的抽象方法。之后再创建一个代理类,同时使其也实现这个接口。在代理类中持有一个被代理对象的引用,而后在代理类方法中调用该对象的方法。
    接口:

    public interface HelloInterface {
        void sayHello();
    }
    

    被代理类:

    public class Hello implements HelloInterface{
        @Override
        public void sayHello() {
            System.out.println("Hello zhanghao!");
        }
    }
    

    代理类:

    public class HelloProxy implements HelloInterface{
        private HelloInterface helloInterface = new Hello();
        @Override
        public void sayHello() {
            System.out.println("Before invoke sayHello" );
            helloInterface.sayHello();
            System.out.println("After invoke sayHello");
        }
    }
    

    代理类调用:
    被代理类被传递给了代理类HelloProxy,代理类在执行具体方法时通过所持用的被代理类完成调用。

    public static void main(String[] args) {
            HelloProxy helloProxy = new HelloProxy();
            helloProxy.sayHello();
        }
        
    输出:
    Before invoke sayHello
    Hello zhanghao!
    After invoke sayHello
    

    使用静态代理很容易就完成了对一个类的代理操作。但是静态代理的缺点也暴露了出来:由于代理只能为一个类服务,如果需要代理的类很多,那么就需要编写大量的代理类,比较繁琐。

    3 动态代理

    利用反射机制在运行时创建代理类。
    接口、被代理类不变,我们构建一个handler类来实现InvocationHandler接口,重写invoke()方法:

    public class ProxyHandler implements InvocationHandler{
        private Object object;
        public ProxyHandler(Object object){
            this.object = object;
        }
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            System.out.println("Before invoke "  + method.getName());
            method.invoke(object, args);
            System.out.println("After invoke " + method.getName());
            return null;
        }
    }
    

    执行动态代理:

    public static void main(String[] args) {
            System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    
            HelloInterface hello = new Hello();
            
            InvocationHandler handler = new ProxyHandler(hello);
    
            HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
    
            proxyHello.sayHello();
        }
        输出:
        Before invoke sayHello
        Hello zhanghao!
        After invoke sayHello
    

    通过Proxy类的静态方法newProxyInstance返回一个接口的代理实例。针对不同的代理类,传入相应的代理程序控制器InvocationHandler。
    如果新来一个被代理类Bye,如:

    public interface ByeInterface {
        void sayBye();
    }
    public class Bye implements ByeInterface {
        @Override
        public void sayBye() {
            System.out.println("Bye zhanghao!");
        }
    }
    

    那么执行过程:

        public static void main(String[] args) {
            System.getProperties().setProperty("sun.misc.ProxyGenerator.saveGeneratedFiles", "true");
    
            HelloInterface hello = new Hello();
            ByeInterface bye = new Bye();
    
            InvocationHandler handler = new ProxyHandler(hello);
            InvocationHandler handler1 = new ProxyHandler(bye);
    
            HelloInterface proxyHello = (HelloInterface) Proxy.newProxyInstance(hello.getClass().getClassLoader(), hello.getClass().getInterfaces(), handler);
    
            ByeInterface proxyBye = (ByeInterface) Proxy.newProxyInstance(bye.getClass().getClassLoader(), bye.getClass().getInterfaces(), handler1);
            proxyHello.sayHello();
            proxyBye.sayBye();
        }
        输出:
        Before invoke sayHello
        Hello zhanghao!
        After invoke sayHello
        Before invoke sayBye
        Bye zhanghao!
        After invoke sayBye
    

    以上内容根据简书https://www.jianshu.com/p/9bcac608c714整理。

    展开全文
  • ios消息机制

    2018-06-01 18:30:00
    1、消息发送 2、动态方法解析 3、消息转发 举例介绍一下 创建一个Pserson类 有一个eat 对象方法 那么下面的代码可以用消息机制实现 导入消息头文件 #import <objc/message.h> // Person * p =...

          ios消息机制介绍

    ios 调用每一个方法的时候其实是走的ios的消息机制

    流程分为3大阶段

    1、消息发送  2、动态方法解析 3、消息转发

    举例介绍一下 创建一个Pserson类 有一个eat 对象方法

    那么下面的代码可以用消息机制实现  导入消息头文件    #import <objc/message.h>

    //    Person * p =[Person alloc];
    
        Person * p = objc_msgSend(objc_getClass("Person"), sel_registerName("alloc"));
    
    //    p= [p init];
        
        p = objc_msgSend(p, sel_registerName("init"));
    
    //    [p eat];
    
        objc_msgSend(p,sel_registerName("eat"));

    转载于:https://www.cnblogs.com/ZhangShengjie/p/9122966.html

    展开全文
  • C++中动态绑定

    2020-02-12 20:17:55
    动态绑定:实际就是多态,多态是指不同的对象,对同一消息的不同响应,通过父类的指针或者引用,调用虚函数时,才会发生动态绑定。 举例如下: #include<iostream> using namespace std; class A { public: ...

    动态绑定:实际就是多态,多态是指不同的对象,对同一消息的不同响应,通过父类的指针或者引用,调用虚函数时,才会发生动态绑定。

    举例如下:

    #include<iostream>
    using namespace std;
    class A
    {
        public:
            int i;
            A():i(10){
    
            }
    
        virtual void f()
        {
            cout<< "A::f()" << i << endl;
        }
    };
    class B:public A
    {
        public:
            int j;
            B():j(20){
    
            }
            void f()
            {
                cout << "B::f()"<< j <<endl;
            }
    
    };
    int main()
    {
        B b;
        A a;
        A c = b;
        A *p = &b;
        p->f();
        A &a1=b;
        a1.f();
        c.f();
        return 0;
    }
    

    运行结果如下所示:
    在这里插入图片描述
    显然指针与引用是可以的,为什么单纯赋值无法实现呢?
    解释如下:
    子类对象赋值给父类,只是实现了公共部分的复制,从而发生数据损失,子类没有复制过去,仍是父类。

    展开全文
  • 静态代理与动态代理

    千次阅读 2017-05-19 18:42:02
    本文对静态代理和动态代理做了一个比较详细的分析和对比,用通俗贴切的例子来举例说明,以便让读者更容易理解和学习 代理模式:代理模式是为另一个对象提供一个替身来控制对这个对象的访问。代理类负责为这个对象...

    代理模式

    一、概念

    代理模式:代理模式是为另一个对象提供一个替身来控制对这个对象的访问。代理类负责为这个对象预处理消息,过滤消息并转发消息,以及进行消息被该对象执行后的后续处理。

    用一个例子说明:客户去买联想电脑,但是他不是直接去厂家去买,而是去一个有联想电脑卖的店去买,这个店就相当于一个代理,它不负责生产电脑,但是客户来买电脑时他转交这个订单给厂家,厂家就先把电脑送到这个店,这个店再给客户。对于客户来说,代理和厂家没有什么区别(都能买到电脑),这样子给客户一种错觉就是,其实客户就是在跟厂家做交易,而实际却不是!有个代理也有个好处,避免了客户对厂家的频繁访问交易,有了代理,厂家就可以专心做生产。对于程序来说,代理对象就可以拦截下许多目标对象不需要或者不想知道的信息,代理类也可以再转发请求给目标对象之前对数据做点处理,总而言之就是,代理类让客户与目标对象解耦,既能满足客户的需求,也能让目标对象只管做好自己的本分工作。


    二、模式图


    三、分类

    按照代理类的创建时期,可分为静态代理和动态代理

    静态:由程序员创建代理类或特定工具自动生成源代码再对其编译。在程序运行前代理类的.class文件就已经存在了。

    动态:在程序运行时运用反射机制动态创建而成。


    静态代理演示示例

    /**
     * 
     * @ClassName StaticProxy.java
     * @Description 用户管理接口
     *
     */
    interface UserManager{
    	//为了代码简洁和清晰阅读,只写一个方法
    	void addUser(String userName);
    }
    
    /**
     * 
     * @ClassName StaticProxy.java
     * @Description 实际操作对象--被代理对象
     *
     */
    class UserManagerImpl implements UserManager{
    
    	@Override
    	public void addUser(String userName) {
    		System.out.println("添加用户成功!用户为:" + userName);
    		
    	}
    	
    }
    /**
     * 
     * @ClassName StaticProxy.java
     * @Description 代理对象,与被代理对象实现同一个接口,这样就达到了隐藏了真正的目标对象,让客户觉得访问代理对象就是在方式真实的对象
     *
     */
    class Proxy implements UserManager{
    
    	private UserManagerImpl umi;
    	
    	public Proxy(UserManagerImpl umi){
    		this.umi = umi;
    	}
    	
    	@Override
    	public void addUser(String userName) {
    		//使用代理的一个好处是可以在对实际对象访问前进行一些必要的处理,控制了对实际对象的访问
    		//在添加之前做一些日志操作
    		System.out.println("添加之前,记录到日志里去……");
    		umi.addUser(userName);
    		//在添加之后也做一些日志操作
    		System.out.println("记录成功!时间:" + new Date());
    	}
    }
    
    public class StaticProxy {
    
    	public static void main(String[] args) {
    		//客户想访问实际对象,只需要访问实际对象的代理对象即可
    		UserManager um = new Proxy(new UserManagerImpl());
    		um.addUser("张三");
    	}
    }

    静态代理类优缺点

     

    优点:

     

    代理使客户端不需要知道实现类是什么,怎么做的,而客户端只需知道代理即可(解耦合)。

     

    缺点:

    1)代理类和委托类实现了相同的接口,代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。

    2)代理对象只服务于一种类型的对象,如果要服务多类型的对象。势必要为每一种对象都进行代理,静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理,但是如果还要为其他类如Department类提供代理的话,就需要我们再次添加代理Department的代理类。

    引入动态代理:

     

    根据如上的介绍,你会发现每个代理类只能为一个接口服务,这样程序开发中必然会产生许多的代理类

    所以我们就会想办法可以通过一个代理类完成全部的代理功能,那么我们就需要用动态代理

     

    在上面的示例中,一个代理只能代理一种类型,而且是在编译器就已经确定被代理的对象。而动态代理是在运行时,通过反射机制实现动态代理,并且能够代理各种类型的对象。

    java内部已经通过反射为我们提供有关动态代理的接口,我们在使用动态代理时,传入相应的参数即可。

    动态代理的模式图



    分析:博主在学习动态代理的时候,很纠结这个InvocationHandler,它到底是用来干嘛的?为什么要用它?

    首先,在动态代理中,Proxy代理类在编译期是不存在的,而是在程序运行时被动态生成的,因为有了反射,可以根据传入的参数,生成你想要的代理(如你想代理A就代理A,想代理B就代理B),实现原理就是在生成Proxy的时候你需要传入被代理类的所有接口(如果没有接口是另一种方式,下文会提),反射机制会根据你传入的所有接口,帮你生成一个也实现这些接口的代理类出来。之后,代理对象每调用一个方法,都会把这个请求转交给InvocationHandler来执行,而在InvocationHandler里则通过反射机制,继续转发请求给真正的目标对象,最后由目标对象来返回结果。或许还有读者疑惑,为什么Proxy不能直接转发请求给目标对象,而是先交给InvocationHandler,(如果你会反射很容易明白)这是因为,要通过反射来转为目标的对象的调用,需要传入调用的方法名,方法所属的类对象以及方法的参数,Proxy不直接转发给目标对象是因为,在程序运行时,Proxy是方法的直接调用者,然后将调用的信息传给InvocationHandlerInvocationHandler再根据传过来的信息并利用反射转为目标对象的最终调用,这个过程中,如果没有Proxy对象的调用,又怎么有运行时的动态信息给反射机制来处理呢,只有Proxy对象调用了,才能够知道有哪些动态信息,而InvocationHandler的作用就是用来接收这些信息,通过反射,进而转为目标对象的调用。

    附上动态代理模式的工作原理图



    下面代码示例

    /**
     * 
     * @ClassName StaticProxy.java
     * @Description 用户管理接口
     *
     */
    interface UserManager{
    	//为了代码简洁和清晰阅读,只写一个方法
    	void addUser(String userName);
    }
    
    //多加一个接口,演示动态代理对象能够代理多个目标对象
    interface Person{
    	void consume(Float money);
    }
    
    /**
     * 
     * @ClassName StaticProxy.java
     * @Description 实际操作对象--被代理对象
     *
     */
    class UserManagerImpl implements UserManager{
    
    	@Override
    	public void addUser(String userName) {
    		System.out.println("添加用户成功!用户为:" + userName);
    		
    	}
    	
    }
    
    class PersonImpl implements Person{
    
    	@Override
    	public void consume(Float money) {
    		System.out.println("消费"+ money + "元");
    		
    	}
    	
    }
    
    /**
     * 
     * @ClassName DynamicProxy.java
     * @Description 日志打印
     *
     */
    class LogHandler implements InvocationHandler{
    
    	private Object tagetObject;
    	
    	//对要代理的目标对象进行绑定,关联到哪个接口(与具体的实现类绑定)的哪些方法将被调用时,执行invoke方法。
    	public Object newProxyInstance(Object tagetObject){
    		System.out.println("=================");
    		this.tagetObject = tagetObject;
    		//第一个参数是:指定目标对象的类加载器
    		//第二个参数:指定目标对象实现的所有接口,让代理对象对目标对象实现同样的接口
    		//第三个参数:指定代理对象要要转发请求给的实现了InvokationHandler的子类,并执行对应的invoke()方法
    		//根据传入的目标对象,产生并返回改目标对象的一个代理对象,这就是动态代理
    		return Proxy.newProxyInstance(tagetObject.getClass().getClassLoader(), 
    				tagetObject.getClass().getInterfaces(), this);
    	}
    	
    	
    	@Override
    	//关联的这个实现类的方法被调用时将被执行  
        /*InvocationHandler接口的方法:proxy表示代理,method表示原对象被调用的方法,args表示方法的参数*/
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		proxy = null;
    		try {
    			System.out.println("记录到日志里去……");
    			proxy = method.invoke(tagetObject, args);
    			System.out.println("记录成功!时间:" + new Date());
    		} catch (Exception e) {
    			e.printStackTrace();
    			System.out.println("操作失败!!");
    			throw e;
    		}
    		
    		return proxy;
    	}
    	
    }
    
    public class DynamicProxy {
    
    	public static void main(String[] args) {
    		//给客户一个InvokationHandler对象,就能动态生成一个代理对象,进而能够访问目标对象
    		LogHandler lh = new LogHandler();
    		UserManager um = (UserManager) lh.newProxyInstance(new UserManagerImpl());
    		System.out.println("******************");
    		um.addUser("张三");
    		
    		//动态代理可以代理多个目标对象,减少了代码重写
    		//如又代理PersonImpl,并不需要额外写其他代码
    		Person p = (Person) lh.newProxyInstance(new PersonImpl());
                    System.out.println("******************");
                   p.consume(88f);
    	}
    }

    程序运行结果



    从运行结果可以看出,

    我们直接调用方法的对象时代理对象,然后Handler里的invoke()方法被自动调用,最后转为了目标对象的调用。

    那怎么实现的呢?根据动态代理的工作原理和实现方式,我们可以猜测,生成的代理类应该是这样


    class $Proxy0 {
    	public Object addUser(String userName) {
    		return handler.invoke(Object proxy, Method method, Object[] args);
    	}
    }

    如此就能实现自动调用Handler的invoke()方法了。

    (如果读者不太好理解动态代理,建议先学习下反射)

    动态代理的优点


    动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样,在接口方法数量比较多的时候,我们可以进行灵活处理,而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一,复用性更强


    总结


    其实所谓代理,就是一个人或者一个机构代表另一个人或者另一个机构采取行动。在一些情况下,一个客户不想或者不能够直接引用一个对象,而代理对象可以在客户端和目标对象之前起到中介的作用。


    代理对象就是把被代理对象包装一层,在其内部做一些额外的工作,比如用户需要上facebook,而普通网络无法直接访问,网络代理帮助用户先翻墙,然后再访问facebook。这就是代理的作用了


    学会了动态代理,再学习AOP就没有那么难了,AOP就是基于动态代理实现的,另见博主另一篇文章。


    希望对读者有帮助!转载请注明出处!

    展开全文
  • 举例:一个服务要将客户发过来的消息进行分类,是水果的调用处理水果的服务器,是蔬菜的调用处理蔬菜的服务器,也就是每台服务器要处理自己队列里的消息。 二、集成MQ 2.1 pom文件引入jar <...
  • iOS消息转发 在OC中是通过 [person eat]调用方法的。 他的底层实现是objc_msgSend(void /* id , self, SEL op, ... */ )。 objc_msgSend需要动态查找自己要调用哪个方法, 会根据@selector的名字动态查找对应的方法。...
  • 6.3.3 列表框消息举例 6.4 组合框消息 6.4.1 组合框消息 6.4.2 组合框消息举例 6.5 按钮控件消息 6.5.1 常用按钮控件消息 6.5.2 程序举例 第7章 设备环境(DC) 7.1 剪裁与坐标转换 7.1.1 剪裁 7.1.2 ...
  • 整个是一个scrollView,嵌套一个线性布局,下拉刷新、或者上拉加载后,通过addView()方法,加载消息体,每一个消息体是一个...下拉刷新的原理网上很详细,简单点说,,拿 "好友动态" 举例,有1、ElasticScrollVie...
  • 整个是一个scrollView,嵌套一个线性布局,下拉刷新、或者上拉加载后,通过addView()方法,加载消息体,每一个消息体是一个复杂的子view。... 下拉刷新的原理网上很详细,简单点说,,拿 "好友动态" 举例,有 1、...
  • 举例:A、B、C这3个系统生产消息后分别想让不同的系统使用广播模式消费消息。A想要系统1、2、3消费同一个消息,B想要系统2、3、4、5消费同一个消息,C想要系统1、2、5、6消费同一个消息。这样消费组的个数相当于在...
  • Collaboration Diagram

    2018-10-06 15:21:28
      协作图是动态图的另一种表现形式,它强调参加交互的各对象的组织。 芝士 协作图的组成元素 对象(Object) 矩形中的内容代表对象 链(Link) 消息 (Message) 举例——客户取车 取车的动作从...
  • 对RunTime的一点认识

    2019-09-29 01:15:25
    对于c语言,函数在编译是就会决定调用,而oc中不会,oc的函数属于一种动态调用。举例说明,oc中只声明一个方法并不去实现它,然后直接调用,编译夺得时候不会报错,只有在运行时报错。类似的情况,在c中是不能通过...
  • HOOK和数据库访问的相关VC 源码实例,主要介绍ADO的三个常用对象:...内容涉及:Windows的消息机制、动态链接库被多个进程访问、数据库访问技术、OLE DB体系架构、ADO的三个核心对象等内容,另附有全部的测试代码。
  • 有经验的iOS开发者应该都知道,Objective-C是动态语言,Objective-C中的方法调用严格来说其实是消息传递。举例来说,调用对象A的hello方法 [A hello]; 复制代码其实是向A对象发送了@selector(hello)消息。 在上一篇...
  • 即时通信应用是一种能够提供人与人之间互相发送消息的功能软件,通过即时通信应用人与人之间可以互相传递消息,所述消息包括 :文字、图片、视频等。随着互联网技术的发展,即时通讯不再满足于纯文本交流,动态表情...
  • 那能不能动态修改,这里有个思路 以udp举例 在客户端里面写一个udp服务,在游戏第一界面打开,比如在登录界面 那么切换这个界面,就可以把这个服务给关掉了。消耗也不大 写个udp的客户端,给游戏客户端的udp服务...
  • C++ 多态性有哪些

    万次阅读 2017-07-03 21:50:50
    概念:指相同的对象收到不同的消息或者不同的对象收到相同的消息时产生的不同的实现动作。 C++支持两种多态:编译时多态(静态)、运行时多态(动态) (1)编译时多态:就是在编译期确定的一种多态。在C++中主要...
  • -举例 -实战机房收费系统 一、交互图 1、交互图:是描述对象之间的关系以及对象之间的信息传递的图,序列图(时序图)、协作图和通信图、交互概览图统称为交互图。 2、理解:从“交互”可以看出,该图是用于描述...
  • 以Windows的USER32模块举例:(USER32模块协助自己的程序和系统进行消息传递等功能) 如果自己写的程序采用静态编译的方式生成执行程序,则使用静态库USER32.LIB.此时是第一种情况.在生成可执行文件时,编译器会把程序...
  • 四大组件之广播(Broadcast)广播简介普通广播...Android 应用与 Android 系统和其他 Android 应用之间可以相互收发广播消息,这与发布-订阅设计模式相似。这些广播会在所关注的事件发生时发送。举例来说,Androi
  • 计算机网络笔记No.5

    2020-03-17 17:55:02
    网络应用之WebWebWeb的构成Web遵循的协议HTTP的连接HTTP连接的两种类型非持久性连接举例持久性连接HTTP消息的格式Cookie技术Web缓存/代理服务器技术 Web Web的构成 网页与网页相互连接的基础——每个网页对象拥有...
  • 发送本地广播举例总结 PS:跳过了第四章(探究碎片),是平板的相关内容 1.广播类型 类型 区别 备注 标准广播 完全异步执行,所有广播接收器同时收到广播消息 效率较高但无法被截断 有序广播 同步执行,按...
  • 程序任务的主要工作式式,举例如下:(1)设置程序的运行控制状态,以便程序再次收到消息时能够正确响应。(2)调用内存中的任务数据进行运算,将运算结果进行保存或显示给用户。(3)生成临时辅助绘图数据并进行...
  • AIS数据解析AIS电文种类暗码数据格式AIS数据部分字符编码比特值与ASCII码的对照表动态信息的格式表ROT参数说明静态信息的格式表船舶和货物类型报告位置参考点和船舶尺寸B类AIS信息的解码过程举例VDM消息类型补充 ...
  • GPRS通用分组无线业务

    热门讨论 2012-08-03 21:14:49
    2.8.2 动态主机配置协议(DHCP) 2.8.3 RADIUS 2.9 协议相关性概述 2.10 TCP/IP的发展——IPv6 2.10.1 IPv6的发展动机 2.10.2 IPv6的特点 2.10.3 IPv6数据包格式 2.10.4 IPv6的分片与重组 第3章 GPRS的业务...
  • 6.5.3 消息映射应用举例 200 6.6 使用Microsoft基础类库 204 6.7 【实例】窗口查看器 206 6.7.1 窗口界面 206 6.7.2 获取目标窗口的信息 211 6.7.3 自制按钮 215 第7章 用户界面设计 219 7.1 对话框...
  • 17.4.3 查看PE文件中的资源列表举例 663 17.5 重定位表 667 17.5.1 重定位表的结构 668 17.5.2 查看PE文件的重定位表举例 670 17.6 应用实例 672 17.6.1 动态获取API入口地址 672 17.6.2 在PE文件上添加执行代码 679...
  • 17.4.3 查看PE文件中的资源列表举例 663 17.5 重定位表 667 17.5.1 重定位表的结构 668 17.5.2 查看PE文件的重定位表举例 670 17.6 应用实例 672 17.6.1 动态获取API入口地址 672 17.6.2 在PE文件上添加执行代码 679...
  • 17.4.3 查看PE文件中的资源列表举例 663 17.5 重定位表 667 17.5.1 重定位表的结构 668 17.5.2 查看PE文件的重定位表举例 670 17.6 应用实例 672 17.6.1 动态获取API入口地址 672 17.6.2 在PE文件上添加执行代码 679...

空空如也

空空如也

1 2 3 4
收藏数 76
精华内容 30
关键字:

动态消息举例