用模式重构

Question

I haven't had a lot of practice with patterns and application architecture. In a nutshell, I have to find certain attributes which object features. Some code will better describe task:

IAttribute {
  IAttribute analyze(IFunction func);
}

//up to 10 different attributes
ArgumentsAttribute implements Attribute {
  Map<String, ArgType> args = new HashMap<>();
  IAttribute analyze(IFunction func) {
    for (Argument arg : func.getArgs()) {
      args.put(arg.getName(), arg.getType());
    }

    if (!args.isEmpty()) return this;
    return null;
  }
}

ReturnAttribute implements Attribute {
  IAttribute analyze(IFunction func) {
    if (func.hasReturn) return this;
    return null;
  }
}


AttributeAnalyzer {
  List<Attributes> analyzeAttributes(IFunction func) {


    List<IAttribute> attributes = new ArrayList<IAttribute>();
    attributes.add(new ArgumentAttribute());
    attributes.add(new ReturnAttribute());
    ...

    for (IAttribute attr : attributes) {
        attr = attr.analyze(func);
        if (null == attr) attributes.remove(attr);
    }

    return attributes;
  }
}

However, this implementation seems to be a little strange. I don't like the fact that Attribute is sort of holder, but it has to implement method to find itself. In my opinion, the best practice would be an opportunity to overload static methods, but obviously its not possible. In this way, we would separate holder from analyzing logic without adding new abstractions(maybe I am not right).

IAttribute {
  static IAttribute analyze();
}

ConcreteAttribute1 {
  int x = 0;
  static IAttribute analyze() {
    ...
    if (x != 0) return new ConcreteAttribute1();
    return null;
  }
}

ConcreteAttribute2 {
  String s = "";
  static IAttribute analyze() {
  ...
  if (!s.equals("")) return new ConcreteAttribute2();
  return null;
  }
}


AttributeAnalyzer {
  List<Attributes> analyzeAttributes() {


    List<IAttribute> attributes = new ArrayList<IAttribute>();
    attributes.add(ConcreteAttribute1.analyze());
    attributes.add(ConcreteAttribute2.analyze());
    ...

    for (IAttribute attr : attributes) {
        if (null == attr) attributes.remove(attr);
    }

    return attributes;
 }

}

In addition, I have to filter spoiled Attributes. So, are there any ways of refactoring to make this code looks better?

Answer 1

If you have a distinct analyze function for each concrete attribute, with little or no overlap, then your initial code sample may not be all that bad. However, I would then change the signature of the method to boolean analyze() .

If there is more overlap in the way attributes are analyzed then you might consider a single method boolean analyze(IAttribute) inside your AttributeAnalyzer class (or in a dedicated class).