精华内容
下载资源
问答
  • Java静态代理

    2020-10-13 13:18:40
    本文讲一下Java静态代理 使用 步骤 1.新建接口 2.新建被代理类a 3.新建代理类b,代理类a中实现接口方法,接口方法中调用被代理类b的方法 4.使用代理类b调用自身方法,实际调用了被代理类a的方法 代码 为了方便,上述...

    前言

    Java中代理有静态代理、动态代理,动态代理中又分JDK动态代理和CGLib动态代理

    本文讲一下Java静态代理

    附上其他两种代理的博文:

    JDK动态代理原理 源码详解

    CGLib动态代理原理 源码详解

    概念

    代理:

    代理角色内部含有对被代理对象的引用,从而可以操作被代理对象

    静态代理:

    就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了

    使用

    步骤

    1.新建接口i

    2.新建被代理类a,实现接口i,

    3.新建代理类b,实现接口i,代理类b在自己的方法中,调用被代理类a的方法

    4.使用代理类b调用自身方法,实际调用了被代理类a的方法

    代码

    为了方便,上述步骤的接口、类都写到一个类下面

    package com.jaylin.jaylin.proxy;
    
    public class StaticProxyTest {
        //接口
        public interface ITestInterface {
            void testMethod();
        }
    
        //被代理类
        static class TestClass implements ITestInterface {
            @Override
            public void testMethod() {
                System.out.println("TestClass");
            }
        }
    
        //代理类
        static class ProxyClass implements ITestInterface {
            //被代理类 实例
            private ITestInterface target = new TestClass();
    
            @Override
            public void testMethod() {
                target.testMethod();
                System.out.println("ProxyClass");
            }
        }
    
        //使用代理
        public static void main(String[] args) {
            ITestInterface proxy= new ProxyClass();
            proxy.testMethod();
        }
    }
    
    
    展开全文
  • Java 静态代理

    万次阅读 2019-12-09 13:53:40
    1)、静态代理。 在程序运行前,代理类的.class文件已存在。事先知道要代理的实现类是什么。 优点:不需要知道委托类(实现类),只需知道代理类即可。 缺点:(1)代码重复。代理类和委托类(实现类)实现了相同...

    1、介绍。

    Java代理。

            java代理:在不用修改源码的情况下,可以在实现类方法的前后做些额外的处理。

      1)、静态代理。

            在程序运行前,代理类的.class文件已存在。事先知道要代理的实现类是什么。

            优点:不需要知道委托类(实现类),只需知道代理类即可。

            缺点:(1)代码重复。代理类和委托类(实现类)实现了相同的接口。
                       (2)维护复杂。接口增加一个方法,所有的代理类和委托类(实现类)都需要实现此方法,而且代理类和委托类(实现类)的关系为一对一,无法一对多。

      2)、动态代理。

            在程序运行时,通过反射机制动态生成代理类。事先不知道要代理的实现类是什么。

            优点:(1)能代理该接口的所有实现类。

                       (2)接口中的所有方法都在InvocationHandler.invoke方法中统一处理,不像静态代理那样每个都进行处理。        缺点:Java动态代理只能代理接口,要代理类需要使用如cglib第三方的类库。

     

    2、代码。Proxy.java、StaticProxyInherit.java、StaticProxy.java、UserServiceImpl.java、IUserService.java、User.java。

    package com.zxj.test.proxy;
    
    import com.zxj.dao.entity.User;
    import com.zxj.dao.service.impl.UserServiceImpl;
    
    public class Proxy {
        private static void staticProxy() {
            User user = new User();
            user.setAge(11);
            user.setName("卓小杰");
    
            //继承委托类(实现类)的方式
            StaticProxyInherit staticProxyInherit = new StaticProxyInherit();
            staticProxyInherit.printInfo(user);
    
            //实现接口的方式
            StaticProxy staticProxy = new StaticProxy(new UserServiceImpl());
            staticProxy.printInfo(user);
        }
    
        public static void main(String[] args) {
            staticProxy();
        }
    }
    
    package com.zxj.test.proxy;
    
    import com.zxj.dao.entity.User;
    import com.zxj.dao.service.impl.UserServiceImpl;
    
    public class StaticProxyInherit extends UserServiceImpl {
        @Override
        public void printInfo(User user) {
            System.out.println("before to do someThing");
            super.printInfo(user);
            System.out.println("after to do someThing");
        }
    }
    
    package com.zxj.test.proxy;
    
    import com.zxj.dao.entity.User;
    import com.zxj.dao.service.IUserService;
    import com.zxj.dao.service.impl.UserServiceImpl;
    
    public class StaticProxy implements IUserService {
        private UserServiceImpl userService;
    
        public StaticProxy(UserServiceImpl userService) {
            this.userService = userService;
        }
    
        @Override
        public void printInfo(User user) {
            System.out.println("before to do someThing");
            userService.printInfo(user);
            System.out.println("after to do someThing");
        }
    }
    
    package com.zxj.dao.service.impl;
    
    import com.zxj.dao.entity.User;
    import com.zxj.dao.service.IUserService;
    
    public class UserServiceImpl implements IUserService {
        @Override
        public void printInfo(User user) {
            System.out.println(String.format("%s已经%d岁了", user.getName(), user.getAge()));
        }
    }
    
    package com.zxj.dao.service;
    
    import com.zxj.dao.entity.User;
    
    public interface IUserService {
        void printInfo(User user);
    }
    
    package com.zxj.dao.entity;
    
    public class User {
        private String name;
        private int age;
    
        public User(){
    
        }
    
        public User(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }
    

    3、结果。

    展开全文
  • java静态代理

    2019-03-16 15:23:27
    静态代理 生活中的代理:我代理小明去买白菜,如果是小明去菜市场买白菜,那么我代理小明去菜市场买白菜,我在小明买白菜的基础上可以买些苹果,梨子等各种东西,就是对小明买白菜这件事的增强 代理对象增强后的对象 目标...

    java设计模式—代理

    静态代理
    生活中的代理:我代理小明去买白菜,如果是小明去菜市场买白菜,那么我代理小明去菜市场买白菜,我在小明买白菜的基础上可以买些苹果,梨子等各种东西,就是对小明买白菜这件事的增强
    代理对象增强后的对象
    目标对象:要增强的对象

    案例一:继承

    java中拿一个用户登录打印用户名的例子:
    写一个类来登录打印登录成功
    1.类UserDaoImpl
    public class UserDaoImpl {
    public void login(String name){
    System.out.println(name+“login success”);
    }
    }

    写另一个类继承UserDaoImpl类重写其中的login方法,并且在重写方法中打印了日志
    2.LogUserProxy
    public class LogUserProxy extends UserDaoImpl {
    @Override
    public void login(String name) {
    System.out.println(“log…”);
    super.login(name);
    }
    }

    3.Test测试类
    public class Test {
    public static void main(String[] args) {
    UserDaoImpl userDao = new LogUserProxy();
    userDao.login(“旺仔”);
    }
    }
    打印结果:
    在这里插入图片描述
    ****案例二:聚合
    1.写一个接口UserDao
    public interface UserDao {
    void login(String name);
    }
    2.使用UserDaoImpl来实现接口,UserDaoImpl为目标对象
    public class UserDaoImpl implements UserDao {
    public void login(String name){
    System.out.println(name+“login success”);
    }
    }
    3.代理类LogUserProxy2来实现UserDao接口,并且在其构造方法中将UserDao对象当参数赋值,LogUserProxy2为代理对象
    public class LogUserProxy2 implements UserDao{
    UserDao userDao;
    public LogUserProxy2(UserDao userDao){
    this.userDao=userDao;
    }

    public void login(String name) {
    System.out.println(“log…”);
    userDao.login(name);
    }
    }
    4.在测试类中使用目标对象对其实例化,将实例化后的对象当参数传入代理对象的构造方法中让其代理,再调用代理对象的登录方法
    public class Test {
    public static void main(String[] args) {
    UserDao userDao = new UserDaoImpl();
    UserDao proxy = new LogUserProxy2(userDao);
    proxy.login(“旺仔”);
    }
    }
    5.测试结果:
    在这里插入图片描述

    展开全文
  • java静态代理与动态代理的区别

    千次阅读 2015-10-25 22:15:22
    java静态代理和动态代理 本文动态代理部分内容大量引自:http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/  一、代理概念  为某个对象提供一个代理,以控制对这个对象的访问。 代理类和委托类有...
    
    
    本文动态代理部分内容大量引自:http://www.ibm.com/developerworks/cn/java/j-lo-proxy1/ 

    一、代理概念 
    为某个对象提供一个代理,以控制对这个对象的访问。 代理类和委托类有共同的父类或父接口,这样在任何使用委托类对象的地方都可以用代理对象替代。代理类负责请求的预处理、过滤、将请求分派给委托类处理、以及委托类执行完请求后的后续处理。 

    图1:代理模式 
     
    从图中可以看出,代理接口(Subject)、代理类(ProxySubject)、委托类(RealSubject)形成一个“品”字结构。 
    根据代理类的生成时间不同可以将代理分为静态代理和动态代理两种。 

    下面以一个模拟需求说明静态代理和动态代理:委托类要处理一项耗时较长的任务,客户类需要打印出执行任务消耗的时间。解决这个问题需要记录任务执行前时间和任务执行后时间,两个时间差就是任务执行消耗的时间。 

    二、静态代理 
    由程序员创建或工具生成代理类的源码,再编译代理类。所谓静态也就是在程序运行前就已经存在代理类的字节码文件,代理类和委托类的关系在运行前就确定了。 
    清单1:代理接口 
    Java代码  收藏代码
    1. /**  
    2.  * 代理接口。处理给定名字的任务。 
    3.  */  
    4. public interface Subject {  
    5.   /** 
    6.    * 执行给定名字的任务。 
    7.     * @param taskName 任务名 
    8.    */  
    9.    public void dealTask(String taskName);   
    10. }  

    清单2:委托类,具体处理业务。 
    Java代码  收藏代码
    1. /** 
    2.  * 真正执行任务的类,实现了代理接口。 
    3.  */  
    4. public class RealSubject implements Subject {  
    5.   
    6.  /** 
    7.   * 执行给定名字的任务。这里打印出任务名,并休眠500ms模拟任务执行了很长时间 
    8.   * @param taskName  
    9.   */  
    10.    @Override  
    11.    public void dealTask(String taskName) {  
    12.       System.out.println("正在执行任务:"+taskName);  
    13.       try {  
    14.          Thread.sleep(500);  
    15.       } catch (InterruptedException e) {  
    16.          e.printStackTrace();  
    17.       }  
    18.    }  
    19. }  

    清单3:静态代理类 
    Java代码  收藏代码
    1. /** 
    2.  * 代理类,实现了代理接口。 
    3.  */  
    4. public class ProxySubject implements Subject {  
    5.  //代理类持有一个委托类的对象引用  
    6.  private Subject delegate;  
    7.    
    8.  public ProxySubject(Subject delegate) {  
    9.   this.delegate = delegate;  
    10.  }  
    11.   
    12.  /** 
    13.   * 将请求分派给委托类执行,记录任务执行前后的时间,时间差即为任务的处理时间 
    14.   *  
    15.   * @param taskName 
    16.   */  
    17.  @Override  
    18.  public void dealTask(String taskName) {  
    19.   long stime = System.currentTimeMillis();   
    20.   //将请求分派给委托类处理  
    21.   delegate.dealTask(taskName);  
    22.   long ftime = System.currentTimeMillis();   
    23.   System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");  
    24.     
    25.  }  
    26. }  

    清单4:生成静态代理类工厂 
    Java代码  收藏代码
    1. public class SubjectStaticFactory {  
    2.  //客户类调用此工厂方法获得代理对象。  
    3.  //对客户类来说,其并不知道返回的是代理类对象还是委托类对象。  
    4.  public static Subject getInstance(){   
    5.   return new ProxySubject(new RealSubject());  
    6.  }  
    7. }  

    清单5:客户类 
    Java代码  收藏代码
    1. public class Client1 {  
    2.   
    3.  public static void main(String[] args) {  
    4.   Subject proxy = SubjectStaticFactory.getInstance();  
    5.   proxy.dealTask("DBQueryTask");  
    6.  }   
    7.   
    8. }  


    静态代理类优缺点 
    优点:业务类只需要关注业务逻辑本身,保证了业务类的重用性。这是代理的共有优点。 
    缺点: 
    1)代理对象的一个接口只服务于一种类型的对象,如果要代理的方法很多,势必要为每一种方法都进行代理,静态代理在程序规模稍大时就无法胜任了。 
    2)如果接口增加一个方法,除了所有实现类需要实现这个方法外,所有代理类也需要实现此方法。增加了代码维护的复杂度。 

    三、动态代理 
    动态代理类的源码是在程序运行期间由JVM根据反射等机制动态的生成,所以不存在代理类的字节码文件。代理类和委托类的关系是在程序运行时确定。 

    1、先看看与动态代理紧密关联的Java API。 
    1)java.lang.reflect.Proxy 
    这是 Java 动态代理机制生成的所有动态代理类的父类,它提供了一组静态方法来为一组接口动态地生成代理类及其对象。 
    清单6:Proxy类的静态方法 
    Java代码  收藏代码
    1. // 方法 1: 该方法用于获取指定代理对象所关联的调用处理器  
    2. static InvocationHandler getInvocationHandler(Object proxy)   
    3.   
    4. // 方法 2:该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象  
    5. static Class getProxyClass(ClassLoader loader, Class[] interfaces)   
    6.   
    7. // 方法 3:该方法用于判断指定类对象是否是一个动态代理类  
    8. static boolean isProxyClass(Class cl)   
    9.   
    10. // 方法 4:该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例  
    11. static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)   


    2)java.lang.reflect.InvocationHandler 
    这是调用处理器接口,它自定义了一个 invoke 方法,用于集中处理在动态代理类对象上的方法调用,通常在该方法中实现对委托类的代理访问。每次生成动态代理类对象时都要指定一个对应的调用处理器对象。 
    清单7:InvocationHandler的核心方法 
    Java代码  收藏代码
    1. // 该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例,第二个参数是被调用的方法对象  
    2. // 第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行  
    3. Object invoke(Object proxy, Method method, Object[] args)   


    3)java.lang.ClassLoader 
    这是类装载器类,负责将类的字节码装载到 Java 虚拟机(JVM)中并为其定义类对象,然后该类才能被使用。Proxy 静态方法生成动态代理类同样需要通过类装载器来进行装载才能使用,它与普通类的唯一区别就是其字节码是由 JVM 在运行时动态生成的而非预存在于任何一个 .class 文件中。 
    每次生成动态代理类对象时都需要指定一个类装载器对象 

    2、动态代理实现步骤 
    具体步骤是: 
    a. 实现InvocationHandler接口创建自己的调用处理器 
    b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类 
    c. 以调用处理器类型为参数,利用反射机制得到动态代理类的构造函数 
    d. 以调用处理器对象为参数,利用动态代理类的构造函数创建动态代理类对象 
    清单8:分步骤实现动态代理 
    Java代码  收藏代码
    1. // InvocationHandlerImpl 实现了 InvocationHandler 接口,并能实现方法调用从代理类到委托类的分派转发  
    2. // 其内部通常包含指向委托类实例的引用,用于真正执行分派转发过来的方法调用  
    3. InvocationHandler handler = new InvocationHandlerImpl(..);   
    4.   
    5. // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象  
    6. Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... });   
    7.   
    8. // 通过反射从生成的类对象获得构造函数对象  
    9. Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class });   
    10.   
    11. // 通过构造函数对象创建动态代理类实例  
    12. Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });   


    Proxy类的静态方法newProxyInstance对上面具体步骤的后三步做了封装,简化了动态代理对象的获取过程。 
    清单9:简化后的动态代理实现 
    Java代码  收藏代码
    1. // InvocationHandlerImpl 实现了 InvocationHandler 接口,并能实现方法调用从代理类到委托类的分派转发  
    2. InvocationHandler handler = new InvocationHandlerImpl(..);   
    3.   
    4. // 通过 Proxy 直接创建动态代理类实例  
    5. Interface proxy = (Interface)Proxy.newProxyInstance( classLoader,   
    6.      new Class[] { Interface.class },  handler );   


    3、动态代理实现示例 
    清单10:创建自己的调用处理器 
    Java代码  收藏代码
    1. /** 
    2.  * 动态代理类对应的调用处理程序类 
    3.  */  
    4. public class SubjectInvocationHandler implements InvocationHandler {  
    5.    
    6.  //代理类持有一个委托类的对象引用  
    7.  private Object delegate;  
    8.    
    9.  public SubjectInvocationHandler(Object delegate) {  
    10.   this.delegate = delegate;  
    11.  }  
    12.    
    13.  @Override  
    14.  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
    15.   long stime = System.currentTimeMillis();   
    16.   //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。  
    17.   //因为示例程序没有返回值,所以这里忽略了返回值处理  
    18.   method.invoke(delegate, args);  
    19.   long ftime = System.currentTimeMillis();   
    20.   System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");  
    21.     
    22.   return null;  
    23.  }  
    24. }   

    清单11:生成动态代理对象的工厂,工厂方法列出了如何生成动态代理类对象的步骤。 
    Java代码  收藏代码
    1. /** 
    2.  * 生成动态代理对象的工厂. 
    3.  */  
    4. public class DynProxyFactory {  
    5.  //客户类调用此工厂方法获得代理对象。  
    6.  //对客户类来说,其并不知道返回的是代理类对象还是委托类对象。  
    7.  public static Subject getInstance(){   
    8.   Subject delegate = new RealSubject();  
    9.   InvocationHandler handler = new SubjectInvocationHandler(delegate);  
    10.   Subject proxy = null;  
    11.   proxy = (Subject)Proxy.newProxyInstance(  
    12.     delegate.getClass().getClassLoader(),   
    13.     delegate.getClass().getInterfaces(),   
    14.     handler);  
    15.   return proxy;  
    16.  }  
    17. }  


    清单12:动态代理客户类 
    Java代码  收藏代码
    1. public class Client {  
    2.   
    3.  public static void main(String[] args) {  
    4.   
    5.   Subject proxy = DynProxyFactory.getInstance();  
    6.   proxy.dealTask("DBQueryTask");  
    7.  }   
    8.   
    9. }  


    4、动态代理机制特点  
    首先是动态生成的代理类本身的一些特点。1)包:如果所代理的接口都是 public 的,那么它将被定义在顶层包(即包路径为空),如果所代理的接口中有非 public 的接口(因为接口不能被定义为 protect 或 private,所以除 public 之外就是默认的 package 访问级别),那么它将被定义在该接口所在包(假设代理了 com.ibm.developerworks 包中的某非 public 接口 A,那么新生成的代理类所在的包就是 com.ibm.developerworks),这样设计的目的是为了最大程度的保证动态代理类不会因为包管理的问题而无法被成功定义并访问;2)类修饰符:该代理类具有 final 和 public 修饰符,意味着它可以被所有的类访问,但是不能被再度继承;3)类名:格式是“$ProxyN”,其中 N 是一个逐一递增的阿拉伯数字,代表 Proxy 类第 N 次生成的动态代理类,值得注意的一点是,并不是每次调用 Proxy 的静态方法创建动态代理类都会使得 N 值增加,原因是如果对同一组接口(包括接口排列的顺序相同)试图重复创建动态代理类,它会很聪明地返回先前已经创建好的代理类的类对象,而不会再尝试去创建一个全新的代理类,这样可以节省不必要的代码重复生成,提高了代理类的创建效率。4)类继承关系:该类的继承关系如图: 

    图2:动态代理类的继承关系 
     


    由图可见,Proxy 类是它的父类,这个规则适用于所有由 Proxy 创建的动态代理类。而且该类还实现了其所代理的一组接口,这就是为什么它能够被安全地类型转换到其所代理的某接口的根本原因。 

    接下来让我们了解一下代理类实例的一些特点。每个实例都会关联一个调用处理器对象,可以通过 Proxy 提供的静态方法 getInvocationHandler 去获得代理类实例的调用处理器对象。在代理类实例上调用其代理的接口中所声明的方法时,这些方法最终都会由调用处理器的 invoke 方法执行,此外,值得注意的是,代理类的根类 java.lang.Object 中有三个方法也同样会被分派到调用处理器的 invoke 方法执行,它们是 hashCode,equals 和 toString,可能的原因有:一是因为这些方法为 public 且非 final 类型,能够被代理类覆盖;二是因为这些方法往往呈现出一个类的某种特征属性,具有一定的区分度,所以为了保证代理类与委托类对外的一致性,这三个方法也应该被分派到委托类执行。当代理的一组接口有重复声明的方法且该方法被调用时,代理类总是从排在最前面的接口中获取方法对象并分派给调用处理器,而无论代理类实例是否正在以该接口(或继承于该接口的某子接口)的形式被外部引用,因为在代理类内部无法区分其当前的被引用类型。 

    接着来了解一下被代理的一组接口有哪些特点。首先,要注意不能有重复的接口,以避免动态代理类代码生成时的编译错误。其次,这些接口对于类装载器必须可见,否则类装载器将无法链接它们,将会导致类定义失败。再次,需被代理的所有非 public 的接口必须在同一个包中,否则代理类生成也会失败。最后,接口的数目不能超过 65535,这是 JVM 设定的限制。 

    最后再来了解一下异常处理方面的特点。从调用处理器接口声明的方法中可以看到理论上它能够抛出任何类型的异常,因为所有的异常都继承于 Throwable 接口,但事实是否如此呢?答案是否定的,原因是我们必须遵守一个继承原则:即子类覆盖父类或实现父接口的方法时,抛出的异常必须在原方法支持的异常列表之内。所以虽然调用处理器理论上讲能够,但实际上往往受限制,除非父接口中的方法支持抛 Throwable 异常。那么如果在 invoke 方法中的确产生了接口方法声明中不支持的异常,那将如何呢?放心,Java 动态代理类已经为我们设计好了解决方法:它将会抛出 UndeclaredThrowableException 异常。这个异常是一个 RuntimeException 类型,所以不会引起编译错误。通过该异常的 getCause 方法,还可以获得原来那个不受支持的异常对象,以便于错误诊断。 

    5、动态代理的优点和美中不足 
    优点: 
    动态代理与静态代理相比较,最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理(InvocationHandler.invoke)。这样,在接口方法数量比较多的时候,我们可以进行灵活处理,而不需要像静态代理那样每一个方法进行中转。在本示例中看不出来,因为invoke方法体内嵌入了具体的外围业务(记录任务处理前后时间并计算时间差),实际中可以类似Spring AOP那样配置外围业务。 

    美中不足: 
    诚然,Proxy 已经设计得非常优美,但是还是有一点点小小的遗憾之处,那就是它始终无法摆脱仅支持 interface 代理的桎梏,因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图,它们已经注定有一个共同的父类叫 Proxy。Java 的继承机制注定了这些动态代理类们无法实现对 class 的动态代理,原因是多继承在 Java 中本质上就行不通。 

    有很多条理由,人们可以否定对 class 代理的必要性,但是同样有一些理由,相信支持 class 动态代理会更美好。接口和类的划分,本就不是很明显,只是到了 Java 中才变得如此的细化。如果只从方法的声明及是否被定义来考量,有一种两者的混合体,它的名字叫抽象类。实现对抽象类的动态代理,相信也有其内在的价值。此外,还有一些历史遗留的类,它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种,不得不说是一个小小的遗憾。
    展开全文
  • JAVA静态代理与动态代理比较 一、概念  代理模式是常用的Java 设计模式,它的特征是代理类与委托类有同样的接口,代理类主要负责为委托类预处理消息、过滤消息、把消息转发给委托类,以及事后处理消息等。代理...
  • 深入浅出java静态代理和动态代理

    千次阅读 热门讨论 2015-07-25 22:05:40
    首先介绍一下,什么是代理:   代理模式,是常用的设计模式。特征是,代理类与委托类有相同的接口,代理类主要负责为...代理类可以分为两种:静态代理和动态代理。     静态代理: 代理类是由程序员创建,或由工具生
  • 静态代理是代理模式实现方式之一,比较简单,主要分为三个角色:客户端,代理类,目标类;而代理类需要与目标类实现同一个接口,并在内部维护目标类的引用,进而执行目标类的接口方法,并实现在不改变目标类的情况下...
  • 1 什么是代理 代理模式的定义:对其他对象提供一种代理以控制对这个对象的访问。举个例子,如A对象有若干个方法,这时A对象对B对象进行委托授权,B对象便成了A对象的代理方,因此B对象便可对A对象进行访问并调用A...
  • 理解Java动态代理需要对Java的反射机制有一定了解 什么是代理模式# 在有些情况下,一个客户不能或者不想直接访问另一个对象,这时需要找一个中介帮忙完成某项任务,这个中介就是代理对象。 例如,购买火车票不一定...
  • * 静态代理类的客户方法 * @author ChenGuanwei * */ public class ClientStaticProxy { public static void main(String[] args) { //先实例化一个目标对象 HelloWorld targetObj = new ...
  • /*静态代理的实现:经常用于记录日志、增强服务 * 以此理解多线程new Thread(线程对象).start();的工作原理 * 模拟婚庆公司 * * 1、真实角色 * 2、代理角色 * 二者实现同一个接口 */ public class ...
  • Java动态代理,Java静态代理,Java代理方式详解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,914
精华内容 61,565
关键字:

java静态代理

java 订阅