Question

最终会有这样的结果：

    ServiceChild (class) extends (or only partial implements) Service and overrides sayHello
    Service (interface) implements hello,goodbye

    Hello (has a mixin HelloMixin) has method sayHello
    Goodbye (has a mixin GoodbyeMixin) has method sayGoodbye

我尝试使用ServiceChild中的关注方法

进行上述操作

    public class ServiceChild extends ConcernOf<Service> implements Hello 
 {

    @Override
    public String sayHello() {
     return "Rulle Pharfar";
    }
 }

但是使用这种方法只有java实现了Hello实现，而不是Service类中的其他东西。那么还有其他方法可行吗？

Answer 1

我不确定我是否理解你要做的事情，但是应该更多地将关注视为一个关注它的原始实现的包装器。正如文档所述：

关注点是一个无状态片段，在调用之间共享，它充当对Mixin调用的拦截器。

通常会这样做：

//Given interface MyStuff
@Mixins( MyStuff.Mixin.class )
@Concerns( MyStuffConcern.class )
public interface MyStuff
{
    public void doStuff();

    abstract class Mixin implements MyStuff
    {
       public void doStuff()
       {
          System.out.println( "Doing original stuff." );
       }
    }
}

public class MyStuffConcern extends ConcernOf<MyStuff>
   implements MyStuff
{
   public void doStuff()
   {
     // if I want to do anything before going down the call chain I'll do it here
     System.out.println( "Doing stuff before original." );

     // calling the next concern or actual implementation
     next.doStuff();

     // anything to do after calling down the call chain - here is the place for it
     System.out.println( "Doing stuff after original." );
   }
}

但是，如果您对接口有疑虑，您还应该实现所述接口：

public abstract class ServiceChild extends ConcernOf<Service> implements Service
{
   public String sayHello()
   {
       return "Rulle Pharfar";
   }
}

希望这会有所帮助。

Answer 2

我也不完全理解这个问题。

正如Arvice所说，关注点相当于AOP中的周围建议，具有更精确的切入点语义。虽然技术上正确的问题是“包裹”潜在的问题/混合，但我宁愿不把它当作“包装”而是“拦截器”。这是处理的来电。从概念上略有不同，它可能对每个人都不起作用。

有问题（无状态）和Mixins（有状态）也可能只实现它们覆盖的接口中的方法的子集，只需将类设为“抽象”即可。 Qi4j将填写缺少（和未使用）的方法调用。可以使用任何组合。

此外，良好实施的问题应该称为“下一个”，因为他们应该不知道他们的实际用途。如果担心预期会照顾方法调用。每个复合类型方法必须有一个Mixin，否则程序集将失败。

总之; 1.Mixin实现可以实现零（a.k.a private mixins），复合类型接口的一个或多个方法。 2.关注点可以实现复合类型接口的一种或多种方法。

值得注意的是，当一个类（mixin或者关注）调用复合类型接口中的一个自己的方法时，调用将不是intra-class，而是从外部调用复合，所以调用整个调用堆栈，以确保内部调用和外部调用在结果中相同。如果需要绕过模式，则存在模式。

Qi4J关注部分实施

2 个答案: