相关疑难解决方法(0)

它是否会影响加载应用程序的时间？或者这样做的任何其他问题？

我有一个客户端库,我在其中对我的休息服务进行http远程调用,然后我返回List<DataResponse>给调用我们的库的客户,我从REST服务获取响应以及任何错误,如果有任何包装DataResponse对象周围.

public class DataResponse {

    private final String response;
    private final boolean isLink;
    private final TypeOfId idType;
    private final long ctime;
    private final long lmd;
    private final String maskInfo;

    // below are for error stuff
    private final ErrorCode error;
    private final StatusCode status;

    // constructors and getters here

}

这是我的ErrorCode枚举类:

public enum ErrorCode {

    // enum values

    private final int code;
    private final String status;
    private final String description;

    // constructors and getters

} …

我有以下java类

public  class TabularDescriptor extends ReportDescriptor {

    private String generatorClass;
    private String targetClass;
    private String name;
    private String sublabel;
    private String reportName;
    private List<MappingMetadata> mappings = null;
    private List<TabularColumnGroup> columnGroups = null;
    private List<TabularStates> states = null;
:
:
     and its getters and settere

对于每个列表，我都有实体类，例如 MappingMetadata、TabularColumnGroup、TabularStates。我想获得这个 pojo 类的 json 数据。我能为它做什么。

还有什么用

    public JSONObject toJSON() {
        JSONObject ret = new JSONObject();
        ret.put("generatorClass", this.generatorClass);
        ret.put("targetClass", this.targetClass);
        ret.put("name", this.name);
        :
        :
        return ret;
    }

无论如何我可以在浏览器上显示我的json内容，如果是的话，我该怎么做？谢谢。

我发现了一种在Java中调用多个方法的新方法,我并不真正了解背后发生的事情:

public class NutritionFacts {
private final int servingSize;
private final int servings;
private final int calories;
private final int fat;
private final int sodium;
private final int carbohydrate;

public static class Builder {
    // Required parameters
    private final int servingSize;
    private final int servings;
    // Optional parameters - initialized to default values
    private int calories      = 0;
    private int fat           = 0;
    private int carbohydrate  = 0;
    private int sodium        = 0;
    public Builder(int servingSize, int servings) {
        this.servingSize …

所以我有一个简单的函数来从数据库中返回一些东西.然后,我可以通过在WHERE子句中添加不同的参数来修改此查询.处理这个问题最优雅有效的方法是什么？

例:

    public static getUsers(int id, string username, string email) {

        Connection conn = null;
        PreparedStatement stmt = null;
        String sql = "";

        sql = "SELECT * FROM users " .........

这就是我对where子句感到困惑的地方.如果我做的事情

"WHERE id = ? AND username = ? AND email = ?";   

如果我只使用Id调用方法,而没有用户名或电子邮件,会发生什么？它会破裂,我不能发生这种情况.

此外,管理我的索引变得很难,因为如果我会做类似的事情stmt.setInt(1, id),但如果我只想用用户名调用该方法,并且该id将以null形式出现,不会抛出NPE？

我是Java的新手,抱歉......但我想我应该使用覆盖？我应该在条件语句中构建我的where子句吗？任何帮助,将不胜感激.

谢谢

我对java很新.有人可以解释一下使用lombok @Builder创建对象而不是构造函数调用的优点吗？

MyObject o1 = MyObject.builder()
              .id(1)
              .name("name")
              .build();

MyObject o2 = new MyObject(1, "name")

这只是一个更好的可见度问题吗？

我看到以下代码语法.调用

ConfigurationBuilder cb = new ConfigurationBuilder();

cb.setDebugEnabled(true)
  .setOAuthConsumerKey("x11")
  .setOAuthConsumerSecret("x33")
  .setOAuthAccessToken("x55")
  .setOAuthAccessTokenSecret("x66");

不使用对象实例的所有方法相继之后.当我想使用这种调用方法时,这如何在我自己的类编程中工作？

在类外使用构建器模式有什么好处？

课内:

public class Person {
    private String name;
    private String eyeColor;
    private String hairColor;

    public Person setName(String name) {
        this.name = name;
        return this;
    }

    public Person setEyeColor(String eyeColor) {
        this.eyeColor = eyeColor;
        return this;
    }

    public Person setHairColor(String hairColor) {
        this.hairColor = hairColor;
        return this;
    }
} 

// Example usage:
Person p = new Person()
                 .setName("Bob")
                 .setHairColor("Black")
                 .setEyeColor("Brown")

课外:

public class Person {
    private String name;
    private String eyeColor;
    private String hairColor;

    public Person(String name, String eyeColor, String …

我目前正在使用 java bean 模型来构造具有许多参数的 POJO

例子：

   Class Person {
   // various fields
   // the getters and setters for the fields
   }

所以为了构建 Person，我做

Person a = new Person();
// then setting all the fields(around 20) using the setters.

现在我正在考虑切换到 java builder 模式来构建这些类型的数据持有者对象。我想在可读性方面，构建器模式更好。那么在效率和性能方面哪个更好？

考虑一下Java中的Message对象，该对象存储一些文本。

public class Message {

    private String text;
    private boolean containsDigit;

    public Message() {
        //constructor
    }

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }

    public boolean isContainsDigit() {
        return containsDigit;
    }

}

这是一个持久的对象。

我在构造函数中设置数据没有问题，但是可以在创建对象之后设置消息的文本字段，并且在设置文本时，此后还可以对containsDigit字段进行查询。显而易见的方法是在设置器中：

public void setText(String text) {
     // presume existence of method to check for digit
     if(text.containsDigit())
         this.containsDigit = true;

     this.text = text;
}

但这是否会由于setter方法中的逻辑而导致任何“最佳实践”警报响起？

有人会建议替代实施吗？

编辑

我可能应该补充一点，该containsDigit字段是必需的，因为该对象是持久性的，因此containsDigit可以随后查询该字段。另外，在使用Spring / Hibernate引擎的应用程序中，在重新读取/写入对象时会不断调用此setter，因此也想知道这样做的实用性/效率。