标签: facade

我想知道一个方法的正确术语,其存在的唯一原因是使方法调用更容易,使方法名称声音/读取更好.

像那样:

public function translate($string)
{
    return Zend_Registry::get('Zend_Translate')->translate($string);
}

我可以称之为适配器,但这是为适配器设计模式保留的.

SRP负责人说:

一个类或模块应该只有一个改变的理由

我有一些Facade类作为我的服务层类.例如SaleService,它提供了一些方法,例如SaveOrder(),CancelOrder(),CreateOrder(),GetAllOrders(),GetAllPlannedOrders(),...

我只是因为他们的概念关系而把它们放在一起.
使用这种方法的类可能有多个改变()的原因,违反了SRP吗？如果是的话,我该如何处理这个问题呢？

阅读有关外观,但不太了解使用的优势,主要是使用MVC.有人可以帮我理解吗？一些更实用的例子？请原谅我的无知!

我有一个被调用的类Awesome,并使用了ServiceProvider和将Facade它注册到应用程序.现在我可以用它作为Awesome::Things().

我想在这个类中添加常量,所以我试过了

<?php namespace Helper\Awesome;
class Awesome()
{
    public static $MOVIE = 'I love the Lego Movie!";
}

但是当我打电话时Awesome::$MOVIE,我明白了Access to undeclared static property: Helper\\Aesome\\Facades\\AwesomeFacade::$MOVIE

有人可以帮忙吗？

我有一个门面类，它实现了以下方法：getTotalNumOfItems(Query query)。该外观位于其他两个实现相同方法的服务类的前面。根据query参数的类型，Facade决定是否委托给其中一个服务或另一个。

我的难题是如何为立面编写单元测试，而无需知道项目数是如何得出的。否则，它将看起来像一个集成测试，而不是一个单元测试。

我已经使用Mockito提供了这两个服务的就地模拟版本。但是，当我为此编写一个单元测试时，我唯一可以测试的是“验证外观是否返回一个数字，等于一个模拟返回的数字（取决于查询类型）”。似乎没有一种方法可以比这更加不可知的方式来测试立面。

我在这里做错什么了吗？我应该担心吗？我猜想，立面的性质就是只能通过了解其委派的类来验证其效率。当然，我确保在两个服务中都为相同的方法编写单元测试。

例如,我想扩展HashSet类,但不是扩展类,而是给新类提供一个引用现有类的实例的私有字段.新类中的每个实例方法都在现有类的包含实例上调用相应的方法并返回结果.这是一种组合和转发方法.

即,例如,我想基于以下内容IDE生成ForwardingSet类Set:

public class ForwardingSet<E> implements Set<E> {
     private final Set<E> s;

     public ForwardingSet(Set<E> s){ 
            this.s = s; 
     }

     public boolean contains(Object o){ 
            return s.contains(o); 
     }

     public boolean isEmpty(){
            return s.isEmpty();
     }


... and etc.

}

那么,我怎么能在它中生成它Idea？

PS:类似的问题在这里,但没有答案.

我需要在Java中实现具有多个接口继承的Facade设计模式,或者是具有Bridge设计模式的正确Facade.我知道这是可能的,因为我把它作为一个系统的一部分看到了,但我不记得实现得很好.
这是我到目前为止的实现:

public interface IOne {
public void methodOneIOne();
public void methodTwoIOne();
}

它的实施:

public class One implements IOne {
@Override
public void methodOneIOne() {
    System.out.println("methodOneIOne()");
}
@Override
public void methodTwoIOne() {
    System.out.println("methodTwoIOne()");
}  }


public interface ITwo {
public void methodOneITwo();
public void methodTwoITwo();
}
public class Two implements ITwo {
@Override
public void methodOneITwo() {
    System.out.println("methodOneITwo()");
}
@Override
public void methodTwoITwo() {
    System.out.println("methodTwoITwo()");
}}

门面:

public interface IFacade extends IOne, ITwo {}

所以,从这里我不知道去哪里.如果我创建一个实现IFacade的类,那么它将需要实现所有方法,这不是我想要的.

在Github上查看一些源代码时,我注意到一些软件包使用app容器本身来访问IOC,而不是Facades.你为什么要用这样的东西......

$app = app();
$user = $app['db']->connection()->table('users')->where('name', '=', 'Foo')->first();

......而不是这个？

$user = User::where('name', '=', 'Foo')->first();

除了Remote Facade pattern更粗粒度的接口和客户端调用此接口是远程而不是本地之外,这两种模式之间是否还有其他差异？

谢谢

我在一个巨大的产品中有一堆我不想使用的类,而是我想将它们的用途重定向到不同的类.这些类(和接口)主要是日志记录类.例如,org.apache.log4j类(很久以前)被采用并在不同的包名下导入源代码,如foo.org.apache.log4j.

现在,我想使用一些使用这些导入和重命名的类但没有这些导入和重命名的类的组件.这是因为导入的源是旧的并且缺乏功能,所以我不能按原样使用它.此外,具有两个不同的log4j实现,旧的导入的和原始的log4j,在配置期间等产生问题.

到目前为止,我的战斗计划是排除不良依赖关系pom.xml并以某种方式自动生成 façades,它将替换不需要的类并重定向到原始库.例如,foo.org.apache.log4j.Logger将被继承自的外观所取代org.apache.log4j.Logger.

现在,是否有任何类型的库或工具可以轻松遍历所定义的所有现有类foo.org.apache.log4j并允许我生成这些外观,或者我是否必须使用反射自行实现所有内容？

我正在通过MSDN关于外观模式的文章. https://msdn.microsoft.com/en-us/library/orm-9780596527730-01-04.aspx#Anchor_0

我无法找到为什么他们将门面变成静态类的原因？为什么他们使用静态变量来保存子系统类的实例？他们为什么使用静态方法？我想知道背后的原因.

下面是该文章的静态代码部分.完整的代码可以在文章中找到.

public static class Facade 
{
     static SubsystemA a = new SubsystemA(  );
     static SubsystemB b = new SubsystemB(  );
     static SubsystemC c = new SubsystemC(  );

     public static void Operation1(  ) {
       Console.WriteLine("Operation 1\n" +
           a.A1(  ) +
           a.A2(  ) +
           b.B1(  ));
    }

     public static void Operation2(  ) {
       Console.WriteLine("Operation 2\n" +
           b.B1(  ) +
           c.C1(  ));
     }
   }

Facade 和 Template 方法模式有什么区别？它们都提供子系统的高级视图并对用户隐藏它。

外观图案

 internal class SubsystemA
    {
        internal string A1()
        {
            return "Subsystem A, Method A1\n";
        }
        internal string A2()
        {
            return "Subsystem A, Method A2\n";
        }
    }
    internal class SubsystemB
    {
        internal string B1()
        {
            return "Subsystem B, Method B1\n";
        }
    }
    internal class SubsystemC
    {
        internal string C1()
        {
            return "Subsystem C, Method C1\n";
        }
    }

    public static class Facade
    {

        static SubsystemA a = new SubsystemA();
        static SubsystemB b = new SubsystemB();
        static SubsystemC c …

\xe2\x80\xa6 我们如何使用面向方面的编程来克服它们？