标签: dynamic-proxy

在的情况下,代理设计模式,是有什么区别JDK的动态代理和第三方动态代码生成API会如CGLIB？

使用这两种方法之间有什么区别？何时应该优先选择另一种方法？

根据文件:

[ java.lang.reflect.] Proxy提供了用于创建动态代理类和实例的静态方法,它也是由这些方法创建的所有动态代理类的超类.

该newProxyMethod方法(负责生成动态代理)具有以下签名:

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
                             throws IllegalArgumentException

不幸的是,这可以防止生成扩展特定抽象类的动态代理(而不是实现特定的接口).这是有道理的,考虑到java.lang.reflect.Proxy"所有动态代理的超类",从而阻止另一个类成为超类.

因此,是否有任何替代方法java.lang.reflect.Proxy可以生成从特定抽象类继承的动态代理,将对抽象方法的所有调用重定向到调用处理程序？

例如,假设我有一个抽象类Dog:

public abstract class Dog {

    public void bark() {
        System.out.println("Woof!");
    }

    public abstract void fetch();

}

是否有一个课程允许我做以下事情？

Dog dog = SomeOtherProxy.newProxyInstance(classLoader, Dog.class, h);

dog.fetch(); // Will be handled by the invocation handler
dog.bark();  // Will NOT be handled by the …

有人可以提供一些建议或指出一些可以帮助做出这个决定的博客/文章吗？代理对我来说似乎很陌生,我对使用它们犹豫不决.我喜欢通过在我的模型中使用虚拟属性来控制延迟加载的能力,但这几乎是我能看到的所有好处.我的应用程序是一个简单的MVC Web应用程序,当实体遇到更改状态时,我不需要将任何挂钩连接到上下文中.

无论如何,这是我现在非常有限的利弊列表,让我知道如果我没有任何这个.

优点

• 在"保存"或"更新"中,我与"Apply'Changes"无缝对接
• 延迟加载配置非常简单.

缺点

• 从来没有为我的实体使用代理,这是一种方法的改变,对我自己和团队成员来说似乎不舒服.
• 调试很尴尬.
• 如果我想要序列化/反序列化,则需要额外的代码
• 在"保存"或"更新"时,代理必须是从上下文中检索的同一对象.

使用动态代理的用例是什么？

它们如何与字节码生成和反射相关？

有推荐的阅读吗？

许多现代框架(Spring,Hibernate)使用Java动态代理提供了非常好的动态行为,但与之相关的确切性能成本是多少？是否有针对Sun JVM的公共基准测试？

正如我们所知道Spring使用代理来增加功能（@Transactional和@Scheduled举例）。有两种选择-使用JDK动态代理（该类必须实现非空接口），或使用CGLIB代码生成器生成子类。我一直认为proxyMode允许我在JDK动态代理和CGLIB之间进行选择。

但是我能够创建一个示例，说明我的假设是错误的：

情况1：

单身人士：

@Service
public class MyBeanA {
    @Autowired
    private MyBeanB myBeanB;

    public void foo() {
        System.out.println(myBeanB.getCounter());
    }

    public MyBeanB getMyBeanB() {
        return myBeanB;
    }
}

原型：

@Service
@Scope(value = "prototype")
public class MyBeanB {
    private static final AtomicLong COUNTER = new AtomicLong(0);

    private Long index;

    public MyBeanB() {
        index = COUNTER.getAndIncrement();
        System.out.println("constructor invocation:" + index);
    }

    @Transactional // just to force Spring to create a proxy
    public long getCounter() {
        return index;
    }
} …

我不知道在春天使用代理的意义.什么是有效的？

我写了一个这样的例子

简单计算器类:

public class Calculator
{
    public int Add(int a, int b)
    {
        return a + b;
    }
}

实现了DynamicProxy提供的"IInterceptor"

 [Serializable]
public abstract class Interceptor : IInterceptor
{
    public void Intercept(IInvocation invocation)
    {
        ExecuteBefore(invocation);
        invocation.Proceed();
        ExecuteAfter(invocation);

    }
    protected abstract void ExecuteAfter(IInvocation invocation);
    protected abstract void ExecuteBefore(IInvocation invocation);
}

创建了一个Interceptor类,并继承自"Interceptor"类

    public class CalculatorInterceptor : Interceptor
{
    protected override void ExecuteBefore(Castle.DynamicProxy.IInvocation invocation)
    {
        Console.WriteLine("Start");
    }

    protected override void ExecuteAfter(Castle.DynamicProxy.IInvocation invocation)
    {
        Console.WriteLine("End");
    }
}

但是当我用它不工作!

static void Main(string[] args)
    {
        ProxyGenerator generator …

我想在Java程序中定义一个方法拦截器,换句话说我希望在每个方法调用中执行一个行为.此应用程序不在应用程序服务器中执行,因此我无法使用EJB调用拦截器.我在标准Java库中找到了一个很好的Proxy API,但它有限,因为它需要在代理创建中使用一个接口:

 Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                      new Class[] { Foo.class },
                                      handler);

是否有类似的API不强制将Foo.class声明为接口？

我需要一些建议,动态代理比常规代理更有用.

我已经投入了大量精力来学习如何有效地使用动态代理.在这个问题中,抛开像AspectJ这样的框架基本上可以执行我们尝试使用动态代理实现的所有内容,或者例如CGLIB可以用来解决动态代理的一些缺点.

用例

• 装饰器 - 例如,执行方法调用的日志记录,或缓存复杂操作的返回值
• 坚持合同 - 即确保参数在可接受的范围内,并且返回类型符合可接受的值.
• 适配器 - 在某个地方看到一些巧妙的文章,描述它是如何有用的.我很少遇到这种设计模式.

是其他人吗？

动态代理优势

• 装饰器:记录所有方法调用,例如,

public Object invoke(Object target, Method method, Object[] arguments) {
         System.out.println("before method " + method.getName());
         return method.invoke(obj, args);
     }
}

装饰器模式肯定是有用的,因为它允许所有代理方法的副作用(尽管这种行为是书籍 - 使用方面的例子..).

• 合同:与常规代理相比,我们不需要实现完整的接口.例如,

public Object invoke(Object target, Method method, Object[] arguments) {
     if ("getValues".equals(method.getName()) {
         // check or transform parameters and/or return types, e.g., 
         return RangeUtils.validateResponse( method.invoke(obj, args) );
     }

     if ("getVersion".equals(method.getName()) {
         // another example with no delegation
         return 3;
     }
} 

另一方面,合同只能避免实现完整接口的需要.然后,重构代理方法将无声地使动态代理无效.

结论 …