标签: proxy-pattern

我在看代理模式,对我而言,它似乎很像装饰器,适配器和桥模式.我误会了什么吗？有什么不同？为什么我会使用Proxy模式而不是其他模式？你过去在现实世界的项目中如何使用它们？

你能解释一下Proxy和Decorator之间的区别吗？

我看到的主要区别在于,当我们假设Proxy使用合成而Decorator使用聚合时,似乎很清楚通过使用多个(一个或多个)装饰器,您可以修改/添加功能到预先存在的实例(装饰),而代理有自己的代理类的内部实例,并委托给它添加一些额外的功能(代理行为).

是个问题-是否代理与聚集创造仍然是代理还是相当装饰？是否允许(通过GoF模式中的定义)创建具有聚合的代理？

我正在尝试找到一种实现依赖于第三方库类的服务的好方法.如果库不可用或无法提供答案,我还有一个'默认'实现用作后备.

public interface Service {

    public Object compute1();

    public Object compute2();
}

public class DefaultService implements Service {

    @Override
    public Object compute1() {
       // ...
    }

    @Override
    public Object compute2() {
        // ...
    }
}

该服务的实际实现将是这样的:

public class ServiceImpl implements Service {
    Service defaultService = new DefaultService();
    ThirdPartyService thirdPartyService = new ThirdPartyService();

    @Override
    public Object compute1() {
        try {
            Object obj = thirdPartyService.customCompute1();
            return obj != null ? obj : defaultService.compute1();
        } 
        catch (Exception e) {
            return defaultService.compute1();
        }
    } …

因此,在我正在创建的使用自定义元素的库中,您显然需要在CustomElementsRegistry实例化之前定义该类.

截至目前,这是由装饰者解决:

class Component extends HTMLElement {

    static register (componentName) {
        return component => {
            window.customElements.define(componentName, component);
            return component;
        }
    }
}

@Component.register('my-element')
class MyElement extends Component { }

document.body.appendChild(new MyElement());

这个工程,不过,我想在这个类(所以笔者并没有给装饰添加到他们写的每一个组成部分)的实例自动注册自定义元素.这可以通过一个完成Proxy.

但问题是,当我尝试在构造函数上使用Proxy,并尝试返回目标的实例时,我仍然会得到Illegal Constructor,就好像该元素从未在注册表中定义一样.

这显然与我在代理中实例化类的方式有关,但我不确定如何做到这一点.我的代码如下:

请在最新的Chrome中运行:

class Component extends HTMLElement {

    static get componentName () {
        return this.name.replace(/[A-Z]/g, char => `-${ char.toLowerCase() }`).substring(1);
    }
}

const ProxiedComponent = new Proxy(Component, {

    construct (target, args, extender) {
        const { componentName } = extender;
  	
        if …

据我所知,适配器和代理模式使两个不同/不同的类/对象与每个相互兼容以进行通信.它们都是结构模式.我发现他们两个都非常相似.

有人可以解释究竟是什么让他们与众不同？

编辑:我经历了这个问题.但我更愿意在Adapter和Proxy之间进行密切的比较.

如何NSProxy在 Swift 中创建子类？

尝试添加任何init方法都会失败并出现错误：“无法在初始化程序之外调用超级初始化”或“从初始化程序返回之前，不会在所有路径上调用超级初始化”

使用 Objective-C 子类作为基类是可行的，但感觉更像是一种 hack：

// Create a base class to use instead of `NSProxy`
@interface WorkingProxyBaseClass : NSProxy
- (instancetype)init;
@end

@implementation WorkingProxyBaseClass
- (instancetype)init
{
  if (self) {

  }
  return self;
}
@end



// Use the newly created Base class to inherit from in Swift
import Foundation

class TestProxy: WorkingProxyBaseClass {
  override init() {
    super.init()
  }
}

So, I was playing around with Proxy objects and while trying to see how they mix with spread syntax and de-structuring, I stubled upon this weird behavior:

const obj = {
  origAttr: 'hi'
}

const handler = {
  get(target, prop) {
    console.log(prop);
    return 1;
  },
  has(target, prop) {
    return true;
  },
  ownKeys(target) {
    return [...Reflect.ownKeys(target), 'a', 'b'];
  },
  getOwnPropertyDescriptor(target, key) {
    return {
      enumerable: true,
      configurable: true
    };
  }
}

const test = new Proxy(obj, handler);
const testSpread = { …

我试图了解代理和动态代理模式之间的区别.从我到目前为止所读到的,我发现的唯一事情是代理类字节代码是在编译期间创建的,而动态代理是在运行时创建的.我还缺少另一个差异吗？如果不是那么更喜欢代理而不是动态代理的原因是什么(性能问题除外)

假设我有一个函数Foo,我希望从它构造的对象具有一个bar属性:

function Foo() {}
Foo.prototype.bar = 'baz'
console.log('new Foo().bar: ' + new Foo().bar)

new Foo().bar: baz

现在假设我以某种方式绑定 Foo.绑定函数仍可用于构造函数调用,并this忽略边界:

const Bound = Foo.bind(42)
console.log('new Bound().bar: ' + new Bound().bar)

new Bound().bar: baz

代理应该是一般的和透明的.然而...

const PFoo = new Proxy(Foo, { })
console.log('new PFoo().bar: ' + new PFoo().bar)

const PBound = new Proxy(Bound, { })
console.log('new PBound().bar: ' + new PBound().bar)

new PFoo().bar: baz
new PBound().bar: undefined

我希望第二个代理的行为完全如此Bound,因为我使用的是空处理程序.换句话说,我希望最后的输出是baz.

为什么不是这样？

(完整的片段如下) …

我有一个类,我想应用代理,观察方法调用和构造函数调用:

Calculator.js

class Calc {
  constructor(){}

  add(a, b) {
    return a+b;
  }

  minus(a, b) {
    return a-b;
  }
}

module.exports = Calc;

index.js

const Calculator = require('./src/Calculator');

const CalculatorLogger = {
  construct: function(target, args, newTarget) {
      console.log('Object instantiated');
      return new target(...args);
  },
  apply: function(target, thisArg, argumentsList) {
      console.log('Method called');
  }
}
const LoggedCalculator = new Proxy(Calculator, CalculatorLogger);
const calculator = new LoggedCalculator();
console.log(calculator.add(1,2));

当调用它时,我希望输出为:

对象实例化

方法叫做

但是,apply没有被调用,我认为这是因为我将Proxy附加到Calculator类,而不是实例化的对象,所以不知道apply陷阱.

如何在方法调用和构造函数调用上构建一个包含所有代理的"观察"代理.