Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Method has 8 parameters, which is greater than 7 authorized

When I am scanning code with sonar lint the following code shows the bug as "Method has 8 parameters, which is greater than 7 authorized"

@PutMapping("/something")
public List<SomeList> updateSomeThing(@PathVariable final SomeCode code,
                                            @PathVariable final SomeId id, 
                                            @PathVariable final String testId,
                                            @PathVariable final String itemId,
                                            @RequestBody final List<Test> someList,
                                            @RequestHeader("test") final String testHeader,
                                            final HttpServletRequest request,
                                            final SomeHeaders someHeaders)

Note: This is a controller method we can not skip any parameters

FYI: Eclipse showing a quick fix as squid:S00107

Anybody have any idea how to resolve this bug?

like image 693
Baji Shaik Avatar asked Mar 28 '18 12:03

Baji Shaik


People also ask

How many parameters can method have?

Parameters are specified after the method name, inside the parentheses. You can add as many parameters as you want, just separate them with a comma.

How many parameters are allowed in a method in Java sonar?

"Constructor has 8 parameters, which is greater than the 7 authorized" for . NET Core framework class constructors · Issue #3459 · SonarSource/sonar-dotnet · GitHub.

How many parameters the methods can accept in Java?

You can add many different types of parameters but java gives a limit, the limit says you can add 255 parameters or less.

How many parameters can a constructor have in Java?

Example of parameterized constructor In this example, we have created the constructor of Student class that have two parameters. We can have any number of parameters in the constructor.


2 Answers

There are two things to consider here.

  1. You can adjust this rule in Sonar and increase the number of authorized parameters. Say put it 10 instead of default (?) 7.

UPD: the advice below is based on the old question version. It might be not applicable to the new question context any more.

  1. But generally you should reconsider your method interface. Having many arguments means that something can be wrong in your architecture and the Single responsibility principle might be broken.

Say in your particular example, I would expect, that you can have an aggregate class Order:

public class Order {
   private CountryCode countryCode;
   private String orderId;
   private User user;
   private String orderId;
   private String item;
   private List<Person> persons;
   private ShippingAddress address;
   private PaymentMethod payment;
   private Product product;
   // ...
}

Which is much logical to manage instead of dealing with many parameters. Then your issues will be solved automatically:

@GetMapping
public void updateSomething(Order order) { ... }
like image 136
Andremoniy Avatar answered Oct 15 '22 18:10

Andremoniy


In general this is a good rule. You should refactor to a Parameter Object or a Builder. However, I tend to ignore this rule when it concerns the creation of a domain model object (like an @Entity) or an immutable object where values are only passed in via the constructor.

like image 24
Coen Damen Avatar answered Oct 15 '22 19:10

Coen Damen