Java 输入参数可空性组合方法的测试

我正在用Java编写一种服务。它涉及到具有许多参数的方法（也有许多类型）。这些方法必须首先测试某些参数的可空性和其他参数的不可空性，以便分派处理（调用其他服务、web服务调用、简单计算、日志记录，有时什么都不做…）

这些方法的签名和正文如下：

public void method(String param1, String param2, Integer param3, long param4, Object param5, List<Object> param6){

if (param1 == null and param2 == null and param2 == null and param3 == null and param4 == null and param5 == null and param6 == null){
// do something

}

else if (param1 != null and param2 == null and param2 == null and param3 == null and param4 == null and param5 == null and param6 == null){

// do something

}


else if (param1 == null and param2 != null and param2 == null and param3 == null and param4 == null and param5 == null and param6 == null){
//do something

}

else if (param1 != null and param2 != null and param2 == null and param3 == null and param4 == null and param5 == null and param6 == null){

}

else if (...){


}


else {

// ...
}




}

public void方法（String param1、String param2、Integer param3、long param4、Object param5、List param6）{
if（param1==null，param2==null，param2==null，param3==null，param4==null，param5==null，param6==null）{
//做点什么
}
else if（param1！=null，param2==null，param2==null，param3==null，param4==null，param5==null，param6==null）{
//做点什么
}
else if（param1==null和param2！=null和param2==null和param3==null和param4==null和param5==null和param6==null）{
//做点什么
}
else if（param1！=null和param2！=null和param2==null和param3==null和param4==null和param5==null和param6==null）{
}
否则如果（…）{
}
否则{
// ...
}
}

实际情况是，我正在使用ajax调用和jQuery对spring控制器方法进行调用

public class MySpringController{

private MyRepo myRepo;
// some attributes 

public List<String> findAllNames(Integer telephoneNumber, String job, Integer birthDate){

if (telephoneNumber == null and job == null and birthDate == null){
  return myRepo.getAllNames()
}

else if (telephoneNumber != null and job == null and birthDate == null)
{
  return myRepo.fetchByTelephone(telephoneNumber);
}

else if (...)
{
//...
}

else 
{
//do something ...
}

}

公共类MySpringController{
私人MyRepo MyRepo；
//一些属性
公共列表findAllNames（整数电话号码、字符串作业、整数生日）{
如果（电话号码==null，工作==null，出生日期==null）{
返回myRepo.getAllNames（）
}
else if（电话号码！=null，工作==null，出生日期==null）
{
返回myRepo.fetchByTelephone（电话号码）；
}
否则如果（…）
{
//...
}
其他的
{
//做点什么。。。
}
}

这个案例促使我扩展我的问题，并想知道是否有一个设计模式

---

我想知道我是否能找到一种更优雅的方法（设计模式可能是）来进行这些测试。示例的编码方式可能会导致一些冗余代码……我不知道您是否同意我的观点，是否对此有建议？

这里有几个选项：

• 责任链：您实现了一个对象的链接列表（每个对象都属于不同的类）。每个对象都会查看是否适合处理该情况，如果适合，则会处理该情况，否则会将其传递给下一个对象

示例代码：

//Handler template
public abstract class FooHandler {

    private FooHandler next;

    protected FooHandler () {
        this(null);
    }

    protected FooHandler (FooHandler next) {
        this.next = next;
    }

    public Result handle (Bar arguments) {
        if(next != null) {
            next.handle(arguments);
        } else {//end of chain, unfortunately no handler found :(
            return null;
        }
    }

}

//Handlers
public class Handler1 extends FooHandler {

    public Handler1 () {}
    public Handler1 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first != null) {//the criteria are met
            return new Result("First handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

public class Handler2 extends FooHandler {

    public Handler2 () {}
    public Handler2 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first == null && arguments.second != null) {//the criteria are met
            return new Result("Second handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

//Construct handler
public class Bar {

    public static void main (String[] args) {
        FooHandler handlerChain = new Handler1(new Handler2());
        Bar bar = new Bar(args);
        FooHandler.handle(bar);
    }

}

---

如果一个条件导致两个新的处理程序，您也可以将其实现为某种二叉树。

这里有几个选项：

• 责任链：您实现了一个对象的链接列表（每个对象都属于不同的类）。每个对象都会查看是否适合处理该情况，如果适合，则会处理该情况，否则会将其传递给下一个对象

示例代码：

//Handler template
public abstract class FooHandler {

    private FooHandler next;

    protected FooHandler () {
        this(null);
    }

    protected FooHandler (FooHandler next) {
        this.next = next;
    }

    public Result handle (Bar arguments) {
        if(next != null) {
            next.handle(arguments);
        } else {//end of chain, unfortunately no handler found :(
            return null;
        }
    }

}

//Handlers
public class Handler1 extends FooHandler {

    public Handler1 () {}
    public Handler1 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first != null) {//the criteria are met
            return new Result("First handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

public class Handler2 extends FooHandler {

    public Handler2 () {}
    public Handler2 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first == null && arguments.second != null) {//the criteria are met
            return new Result("Second handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

//Construct handler
public class Bar {

    public static void main (String[] args) {
        FooHandler handlerChain = new Handler1(new Handler2());
        Bar bar = new Bar(args);
        FooHandler.handle(bar);
    }

}

---

如果一个条件导致两个新的处理程序，您也可以将其实现为某种二叉树。

这里有几个选项：

• 责任链：您实现了一个对象的链接列表（每个对象都属于不同的类）。每个对象都会查看是否适合处理该情况，如果适合，则会处理该情况，否则会将其传递给下一个对象

示例代码：

//Handler template
public abstract class FooHandler {

    private FooHandler next;

    protected FooHandler () {
        this(null);
    }

    protected FooHandler (FooHandler next) {
        this.next = next;
    }

    public Result handle (Bar arguments) {
        if(next != null) {
            next.handle(arguments);
        } else {//end of chain, unfortunately no handler found :(
            return null;
        }
    }

}

//Handlers
public class Handler1 extends FooHandler {

    public Handler1 () {}
    public Handler1 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first != null) {//the criteria are met
            return new Result("First handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

public class Handler2 extends FooHandler {

    public Handler2 () {}
    public Handler2 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first == null && arguments.second != null) {//the criteria are met
            return new Result("Second handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

//Construct handler
public class Bar {

    public static void main (String[] args) {
        FooHandler handlerChain = new Handler1(new Handler2());
        Bar bar = new Bar(args);
        FooHandler.handle(bar);
    }

}

---

如果一个条件导致两个新的处理程序，您也可以将其实现为某种二叉树。

这里有几个选项：

• 责任链：您实现了一个对象的链接列表（每个对象都属于不同的类）。每个对象都会查看是否适合处理该情况，如果适合，则会处理该情况，否则会将其传递给下一个对象

示例代码：

//Handler template
public abstract class FooHandler {

    private FooHandler next;

    protected FooHandler () {
        this(null);
    }

    protected FooHandler (FooHandler next) {
        this.next = next;
    }

    public Result handle (Bar arguments) {
        if(next != null) {
            next.handle(arguments);
        } else {//end of chain, unfortunately no handler found :(
            return null;
        }
    }

}

//Handlers
public class Handler1 extends FooHandler {

    public Handler1 () {}
    public Handler1 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first != null) {//the criteria are met
            return new Result("First handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

public class Handler2 extends FooHandler {

    public Handler2 () {}
    public Handler2 (FooHandler next) {
        super(next);
    }

    public Result handle (Bar arguments) {
        if(arguments.first == null && arguments.second != null) {//the criteria are met
            return new Result("Second handler's result.");
        } else {
            super.handle(arguments);
        }
    }

}

//Construct handler
public class Bar {

    public static void main (String[] args) {
        FooHandler handlerChain = new Handler1(new Handler2());
        Bar bar = new Bar(args);
        FooHandler.handle(bar);
    }

}

---

如果一个条件导致两个新的处理程序，您也可以将其实现为某种二叉树。

下面是您的代码的外观：

public List<String> findAllNames(Integer telephoneNumber, String job, Integer birthDate) {
    return myRepo.fetchByCriteria(telephoneNumber, job, birthDate);
}

public List<String> fetchByCriteria(Integer telephoneNumber, String job, Integer birthDate) {
    String sql = "select name from user u where 1 = 1";
    List<Object> parameters = new ArrayList<>();
    if (telephoneNumber != null) {
        sql += " and u.phone = ?";
        parameters.add(telephoneNumber);
    }
    if (job != null) {
        sql += " and u.job = ?";
        parameters.add(job);
    }
    if (birthDate != null) {
        sql += " and u.birthDate = ?";
        parameters.add(birthDate);
    }

    ...

}

public List findAllNames（整数电话号码、字符串作业、整数生日）{
返回myRepo.fetchByCriteria（电话号码、工作、出生日期）；
}

在存储库中，您应该根据条件的值编写查询。JPA有一个专门为此类用例设计的条件API。如果使用SQL，代码可能如下所示：

public List<String> findAllNames(Integer telephoneNumber, String job, Integer birthDate) {
    return myRepo.fetchByCriteria(telephoneNumber, job, birthDate);
}

public List<String> fetchByCriteria(Integer telephoneNumber, String job, Integer birthDate) {
    String sql = "select name from user u where 1 = 1";
    List<Object> parameters = new ArrayList<>();
    if (telephoneNumber != null) {
        sql += " and u.phone = ?";
        parameters.add(telephoneNumber);
    }
    if (job != null) {
        sql += " and u.job = ?";
        parameters.add(job);
    }
    if (birthDate != null) {
        sql += " and u.birthDate = ?";
        parameters.add(birthDate);
    }

    ...

}

公共列表fetchByCriteria（整数电话号码、字符串作业、整数生日）{
String sql=“从用户u中选择名称，其中1=1”；
列表参数=新的ArrayList（）；
如果（电话号码！=null）{
sql+=“和u.phone=？”；
参数。添加（电话号码）；
}
如果（作业！=null）{
sql+=“和u.job=？”；
参数。添加（作业）；
}
如果（生日！=null）{
sql+=“和u.birthDate=？”；
参数。添加（生日）；
}
...
}

---

当然，也有允许动态组合此类SQL查询的API（我想到了JOOQ）。

以下是您的代码：

public List<String> findAllNames(Integer telephoneNumber, String job, Integer birthDate) {
    return myRepo.fetchByCriteria(telephoneNumber, job, birthDate);
}

public List<String> fetchByCriteria(Integer telephoneNumber, String job, Integer birthDate) {
    String sql = "select name from user u where 1 = 1";
    List<Object> parameters = new ArrayList<>();
    if (telephoneNumber != null) {
        sql += " and u.phone = ?";
        parameters.add(telephoneNumber);
    }
    if (job != null) {
        sql += " and u.job = ?";
        parameters.add(job);
    }
    if (birthDate != null) {
        sql += " and u.birthDate = ?";
        parameters.add(birthDate);
    }

    ...

}

public List findAllNames（整数电话号码、字符串作业、整数生日）{
返回myRepo.fetchByCriteria（电话号码、工作、出生日期）；
}

在存储库中，您应该根据条件的值编写查询。JPA有一个专门为此类用例设计的条件API。如果使用SQL，代码可能如下所示：

public List<String> findAllNames(Integer telephoneNumber, String job, Integer birthDate) {
    return myRepo.fetchByCriteria(telephoneNumber, job, birthDate);
}

public List<String> fetchByCriteria(Integer telephoneNumber, String job, Integer birthDate) {
    String sql = "select name from user u where 1 = 1";
    List<Object> parameters = new ArrayList<>();
    if (telephoneNumber != null) {
        sql += " and u.phone = ?";
        parameters.add(telephoneNumber);
    }
    if (job != null) {
        sql += " and u.job = ?";
        parameters.add(job);
    }
    if (birthDate != null) {
        sql += " and u.birthDate = ?";
        parameters.add(birthDate);
    }

    ...

}

公共列表fetchByCriteria（整数电话号码、字符串作业、整数生日）{
String sql=“从用户u中选择名称，其中1=1”；
列表参数=新的ArrayList（）；
如果（电话号码！=null）{
sql+=“和u.phone=？”；
参数。添加（电话号码）；
}
如果（作业！=null）{
sql+=“和u.job=？”；
参数。添加（作业）；
}
如果（生日！=null）{
sql+=“和u.birthDate=？”；
参数。添加（生日）；
}
...
}

当然，也有允许动态组合此类SQL查询的API