小编Duš*_*ský的帖子

假设我正在设计REST API，并且我需要客户端能够获取带有元数据的文件。设计资源/运营的好方法是什么？

我想到了一些想法：

• 单个资源（即GET / files / {fileId}），它返回包含文件和带有元数据的JSON / XML结构的多部分响应。我觉得这不是一个很好的方法。例如，您不能为客户端使用Accept标头来确定它们是否需要XML或JSON元数据表示，因为在两种情况下响应类型都是多部分的。

• 两种资源（即GET / files / {fileId}和GET / files / {fileId} / metadata），其中第一个返回文件本身，第二个返回带有元数据的JSON / XML结构。从元数据到文件可以有一个链接。但是，如何与文件一起发送指向元数据的链接？

根据关于 ID 属性类型的 DTD 规范：

有效性约束：ID

ID 类型的值必须与 Name 产生式匹配。一个名称不得在 XML 文档中作为这种类型的值出现多次；即，ID 值必须唯一标识承载它们的元素。

以下哪个解释是正确的？

1. 类型 ID 的所有属性的所有实例的值必须不同。
2. 类型 ID 的相同属性的所有实例的值必须不同。

换句话说，给定以下 DTD 声明片段：

<!ELEMENT book ANY>
<!ATTLIST book id ID>

<!ELEMENT magazine ANY>
<!ATTLIST magazine id ID>

以下 XML 文档片段是否违反了有效性约束？

<book id="ID01" />
<magazine id="ID01" />

如果我将属性重命名为book-idand magazine-id，而不是id在两种情况下都重命名呢？

假设我有以下java类映射到我的REST服务的请求主体以搜索用户.

@XmlRootElement(name = "SearchParams")
@XmlType(propOrder = {})
public class SearchParams {

  private String firstname;
  private String lastname;
  private List<String> role;

  ...
}

注意propOrder的参数@XmlType注解-它宣称,在代表各自的属性出现在XML文件中的顺序并不重要,因此是XSD:所有应该被用来代替XSD:序列中生成的XSD架构.

但是,正如您所看到的,其中一个属性(角色属性)是一个列表,因此对应一个具有无界maxOccurs的元素.

似乎在xsd:all complexType中不允许具有无界maxOccurs的元素.我该如何避免这个问题？

需要注意的是,不同的角色,将名字和姓氏具有的maxOccurs的1.因此,我不能使用无界的xsd:choice而不是xsd:all.

什么是与OCL中的forAll方法等效的Groovy？

假设我有一个项目列表.

def items = new LinkedList<Item>();

当且仅当所有项都符合特定条件时,Groovy表达谓词的方式是什么？

以下代码片段不起作用,因为内部返回仅跳出每个闭包的当前迭代,而不是跳出forAll方法.

boolean forAll(def items)
{
    items.each { item -> if (!item.matchesCriteria()) return false; };
    return true;
}

下面的代码片段应该可以解决问题,感觉很麻烦而且不像Groovy.

boolean forAll(def items)
{
    boolean acceptable = true;
    items.each { item -> if (!item.matchesCriteria()) acceptable = false; };
    return acceptable;
}

我正在寻找一种方法来懒惰地评估谓词,以便在找到第一个不匹配的项目时完成评估.

假设我有一个复合层次结构来表示常规表达式,如下所示:

public abstract class Expression {
  public abstract void accept(Visitor visitor);
}

public class Identifier extends Expression {
  public final String token;

  public Identifier(String token) {
    this.token = token;
  }

  @Override
  public void accept(Visitor visitor) {
    visitor.visit(this);
  }

  public String getToken() {
    return token;
  }
}

public class Sequence extends Expression {
  private final List<Expression> subExprs;

  public Sequence(List<Expression> subExprs) {
    this.subExprs = new ArrayList<Expression>(subExprs);
  }

  @Override
  public void accept(Visitor visitor) {
    visitor.visit(this);
  }

  public List<Expression> getSubExprs() {
    return subExprs;
  } …

在我的项目中,我有多个严格排序的类型,我需要它们全部支持范围操作 - 给定两个边界值,返回所有中间值的列表.

为了不重复自己,我会创建一个像下面这样的"特征",它将声明相应的基本操作并在顶部构建一个范围方法.

public interface Navigable {

    public Navigable previous() throws UnsupportedOperationException;

    public boolean isFirst();

    public Navigable next() throws UnsupportedOperationException;

    public boolean isLast();

    public boolean precedes(Navigable other);

    public default List<Navigable> range(Navigable to) {

        Navigable from = this;

        boolean invert = to.precedes(from);
        if (invert) {
            Navigable tmp = from;
            from = to;
            to = tmp;
        }

        List<Navigable> result = new LinkedList<>();

        while (from.precedes(to)) {
            result.add(from);
            from = from.next();
        }

        result.add(to);

        if (invert) {
            reverse(result);
        }

        return result;
    }
}

但是,有了这样的接口,我需要实现这样的操作: …

我正在我的Web应用程序中创建一个带有选择框的表单.我以下面描述的方式使用DropDownChoice + ChoiceRenderer组合.它工作正常,但一方面 - in不预先选择默认值.

我一直在努力解决这个问题很长一段时间.我在互联网上找到了几个据说可行的例子,但它们对我不起作用.

我的代码库看起来像这样(不相关的部分已被省略或简化以提高清晰度):

商业实体

public class MultivalueType
{
    private Long id;
    private String label;
    private String description;

    public MultivalueType(Long id, String label, String description) 
    {
        this.id = id
        this.label = label;
        this.description = description;
    }

    public Long getId()
    {
        return id;
    }

    public String getLabel() 
    {
        return label;
    }

    public String getDescription() 
    {
        return description;
    }
}

public class PropertySettings
{
    private Long id;
    private String property;
    private MultivalueType multivalueType;

    public PropertySettings(Long id, String property, MultivalueType …

在哪里可以找到官方 DTD 规范？与 XPath 和 XML Schema 不同，我似乎无法在 W3C 网页上找到 DTD 规范，也无法通过 google.com 找到它。

在W3c的规范中,我似乎无法找到允许在XML文档中的属性值中出现的字符集的定义.

1. 它与元素的文本内容是否相同？
2. 或者它只是一个子集(例如\n除外)？

请引用说明书的部分来回答我的问题.

今天，我对得到的 Visual VM 分析结果感到困惑。

我有以下简单的Java方法：

public class Encoder {
  ...
  private BitString encode(InputStream in, Map<Character, BitString> table) 
      throws IOException {

    BufferedReader reader = new BufferedReader(new InputStreamReader(in));

    BitString result = new BitString();
    int i;
    while ((i = reader.read()) != -1) {
      char ch = (char) i;
      BitString string = table.get(ch);
      result = result.append(string);
    }

    return result;
  }
}

此方法从流中一次读取一个字符。对于每个字符，它查找它的位串表示形式，并将这些位串连接起来以表示整个流。

BitString 是一种自定义数据结构，它使用底层字节数组表示位序列。

该方法的性能非常差。问题在于BitString#append- 该方法创建一个新的字节数组，从两个输入 BitString 复制位并将其作为新的 BitString 实例返回。

public BitString append(BitString other) {

  BitString result = new BitString(size + other.size); …

我在Ruby中编写脚本并意识到我需要使用该Enumerable#sum方法.但是,该方法仅存在于Ruby 2.4及更高版本中 - 我有2.2.

所以我可以自己添加这个方法,就像这样

module Enumerable
  def sum(init = 0, &block)
    block ||= lambda { |x| x }
    map(&block).inject(init, :+)
  end
end

但是如果我在具有足够高版本Ruby的PC上运行脚本,我的实现将覆盖标准库中的那个.

Enumerable#sum当且仅当它不存在时,我该如何实现该方法？

考虑以下两种C＃方法。尽管功能上等效，但第一个指令似乎表现更好，如相应的IL指令所建议。

快点：

static Task<string> Proxy(string text)
{
  return Foo(text);
}

慢点：

static async Task<string> ProxyAsync(string text)
{
  return await Foo(text);
}

据我了解，引擎盖下的编译器用复杂的状态机代替了等待指令。

为什么编译器无法自动优化这种琐碎的情况？
这似乎是影响力不大的低落果实。

同样，在C＃代码中手动进行此类优化的（缺点）有哪些（即，有意偏向于较快的实现而不是较慢的实现）。