标签: proxy-pattern

似乎Proxy和Adapter模式之间有相似之处？

任何人都可以解释一下有什么区别吗？为什么我们要求他们两个？在哪些问题中我们应该只使用代理而不是另一个.net示例？

谢谢

我正在学习 Spring Core 认证，我发现一些与代理概念相关的疑问。

所以在学习材料上，我找到了以下测验：

有一个 Java配置类，其中包含以下方法：

@Bean
public AccountRepository accountRepository(){ 
    return new JdbcAccountRepository(); 
}

@Bean
public TransferService transferService1() {
    TransferServiceImpl service = new TransferServiceImpl();
    service.setAccountRepository(accountRepository());
    return service;
}

@Bean
public TransferService transferService2() {
    return new TransferServiceImpl( new JdbcAccountRepository() );
}

如您所见，transferService()有两种不同的实现，分别命名为transferService1()和transferService2()，它们创建并返回TransferServiceImpl对象。

第一个创建一个新的TransferServiceImpl对象，然后对其调用setAccountRepository()方法。

第二个只是创建一个TransferServiceImpl将一个新的JdbcAccountRepository对象传递给它的构造函数。

它问我**前两种方法的最佳实现是什么？

提供的答案是：首选调用专用方法。所以我认为它说最好的方法是第一个实现。

它解释说AccountRepository bean 是一个单例（因为它是 Spring 中 bean 的标准范围）但是JdbcAccountRepository()可以被调用两次或更多次（例如在前面的代码片段中，它在调用方法时被调用 …

我正在尝试将 Python 包装PyObject*在一个Object类中。在 Python 中，一切都是PyObject*. 列表是 a PyObject*，列表中的每一项本身就是 a PyObject*。这甚至可能是另一个列表。等等。

我试图fooList[42] = barObj通过代理模式（here）来允许样式语法。

现在我已经可以工作了，我想扩展它，以便fooList[42]可以将其用作Object. 具体来说，我希望能够处理...

fooList[42].myObjMethod()
fooList[42].myObjMember = ...

Object有很多方法，目前fooList[42].myObjMethod()将首先解析fooList[42]为一个Proxy实例，比如tmpProxy，然后尝试tmpProxy.myObjMethod()。

这意味着我将不得不做

void Proxy::myObjMethod(){ return wrapped_ob.myObjMethod(); }

即通过 手动中继每个Object方法Proxy，这很丑陋。

我看不到任何完美的解决方案（请参阅上面链接的答案），但我很乐意使用：

fooList[42]->myObjMethod()

... 作为妥协，将 as -> 视为可以重载（而不是.不能）。

但是，我找不到任何有关重载的文档operator->。

我最好的猜测是它必须返回一个指向某个对象的指针（比如pObj），而 C++ 将调用pObj->whatever. …

我正在尝试使用swift实现代理模式,以便为从NSObject继承的自定义对象创建配置对象.这对于UIView来说就像UIAppearance.但我不明白如何进行方法调用转发,我会在Objective-c中使用forwardInvocation:方法和NSInvocation类进行.

如果有人遇到这样的问题并找到解决方案,我会很感激.提前致谢.

代理模式在进行了一些其他处理（例如应用检查是否需要处理请求还是基于某些凭据检查）之后，将请求委托给Real主题。

它的类图如下

代理类直接引用了具体的Subject。

装饰器模式丰富了组件的行为（像代理一样，它也进行一些附加处理并将操作委托给实际组件）。此模式的类图类似于Proxy模式，唯一的区别是它具有对组件接口的引用。

在Proxy类中拥有具体的实际主题会使单元测试变得困难，因为类仅应依赖于接口而不是依赖于实现。我的问题是，如果代理模式也引用了Real主体公开的接口，那么它将等同于Decorator模式。在这种情况下，代理模式的类图也将如下所示

如果我在 JVM 上，我可以这样做：

object Playground {

    class DynamicInvocationHandler : InvocationHandler {

        @Throws(Throwable::class)
        override operator fun invoke(proxy: Any, method: Method, args: Array<Any>): Any {
            LOGGER.info("Invoked method: {}", method.name)

            return 42
        }

        companion object {

            private val LOGGER = LoggerFactory.getLogger(
                    DynamicInvocationHandler::class.java)
        }
    }

    @JvmStatic
    fun main(args: Array<String>) {
        val proxy = Proxy.newProxyInstance(
                Playground::class.java.classLoader,
                arrayOf<Class<*>>(MutableMap::class.java),
                DynamicInvocationHandler()) as MutableMap<String, String>

        proxy["foo"] = "bar"
    }
}

运行此命令将打印Invoked method: put. 我怎样才能在 Kotlin公共项目中做这样的事情？

编辑：我不想在我的公共模块中使用 Java 中的任何内容。我知道常见项目是如何运作的。我感兴趣的是是否有基于 Kotlin 的解决方案。

编辑2：我不想代理该类Map。我正在寻找类似Proxy …

我一直在学习设计模式,我从类中看到了这样一个方法调用:

class Client: SubjectAccessor {
    static void Main() {
        Console.WriteLine("Proxy Pattern\n");

        ISubject subject = new Proxy();
        Console.WriteLine(subject.Requesy());

        subject = new(); //Here is what I am asking
        COnsole.WriteLine(subject.Request());
    }
}

你可以看到那里有一个subject = new();电话,我想知道它是否正在创建一个新的实例Proxy或其他东西.我没有发现任何与此相关的内容.

非常感谢您的帮助.

如果你需要,我可以粘贴整个代码或实际上它写在书上,所以我需要在这里写下来.

谢谢.

我一直在阅读,当你要求在bean中注入依赖项时,你会向该资源的一个实例注入一个代理.我相信我知道代理是什么,它是一个知道如何将消息转发到另一个实例的实例.它还声明,正是这种模式允许容器为这个托管bean提供服务.

我不太了解这一点.为什么需要代理？这是如何实现的？每个bean都有一个代理对象吗？或者我有很多代理转发到一个实例？或者两者都不是？

另外,根据GoF的书籍设计模式,我已经读过你必须提供一个充当占位符的代理类.但我从来没有在Java EE中这样做,应用服务器是否在运行时创建代理类？

它只发生在#toString, 并且只有当我（尝试）通过missingMethod-like访问它时trap。

我有一个工厂createIterface，它返回一个Proxy具有大量方法的对象。在这些方法中，我有#toString()和#id()。#id返回interface与调用者具有相同属性的 并且工作正常；#toString应该将 my 转换interface为字符串，但它失败了。Allinterface的方法——包括#id和#toString——都在一个#Symbol.for("__methods")属性中。我这样做是为了调试的目的：

const __methods = Symbol.for("__methods");

const missingMethod = ({
    get: (obj, prop) => Reflect.has(obj, prop)
        ? Reflect.get(obj, prop)
        : Reflect.has(obj[__methods], prop)
            ? Reflect.get(obj[__methods], prop)
            : console.log(`No #${prop} property exists.`)
});

const createInterface = (...props) => new Proxy({
    ...props,
    [__methods]: {
        id: () => createInterface (...props), …

我正在尝试为另一个类创建一个Proxy类.我希望这个类在其构造函数中传递给代理,然后让代理动态地创建此类的所有相同方法.

这是我到目前为止无法正常工作的原因:

import inspect
from optparse import OptionParser

class MyClass:

    def func1(self):
        print 'MyClass.func1'


    def func2(self):
        print 'MyClass.func1'


class ProxyClass:

    def __init__(self):
        myClass = MyClass()
        members = inspect.getmembers(MyClass, predicate=inspect.ismethod)
        for member in members:
            funcName = member[0]
            def fn(self):
                print 'ProxyClass.' + funcName
                return myClass[funcName]()
            self.__dict__[funcName] = fn

proxyClass = ProxyClass()
proxyClass.func1()
proxyClass.func2()

我认为这是self.__dict__[funcName] = fn需要改变的线,但我不知道该怎么做？

我是Python的新手,所以如果有一种完全不同的Pythonic方式,我也很乐意听到这个.