Java class validation with annotation - java

I'm using Spring Boot.
I'm writing a Java class and I would like to make a validation using the annotations.
Something like this:
#Getter #Setter
#Validated
public class User {
#NotBlank(message = "Username cannot be empty")
private String username;
#NotBlank(message = "Email address cannot be empty")
#Email(message = "Please provide valid email address")
private String email;
#NotBlank(message = "First Name cannot be empty")
private String firstName;
#NotBlank(message = "Last Name cannot be empty")
private String lastName;
}
I would like to rise an exception if I try to create a new object with wrong parameters.
Same result if I will try to use a setter with wrong parameter.
Is it' possible? Is my code wrong?


You can invoke validator by yourself
#Component
class SomeComponent{
private Validator validator;
SomeComponent(Validator validator){
this.validator = validator;
}
void validateInput(Input input) {
ValidatorFactory factory = Validation.buildDefaultValidatorFactory();
Set<ConstraintViolation<Input>> violations = validator.validate(input);
if (!violations.isEmpty()) {
throw new ConstraintViolationException(violations);
}
}
}
You can trigger in Post Constructor method and in setters


You can use Hibernate Validator for Annotation validations
https://docs.jboss.org/hibernate/stable/validator/reference/en-US/html_single/#validator-gettingstarted-createmodel

Related

How to return true or false based on validating the data in Validator class in Spring boot validator

public class IsCompleteSizing {
#NotNull(message = "Size model may not be null")
#Valid
private IsValidData1 sizeModel;
#NotNull(message = "Size Range may not be null")
#Valid
private IsValidData2 sizeRange;
#NotNull(message = "Size Profile may not be null")
#Valid
private IsValidData3 sizeProfile;
private List<IsValidList> isValidListOfItems;
}
as shown in the above class, I want to validate like
isValid((IsValidData1 && IsValidData2 && IsValidData3) || (IsValidList))
I want to achieve this approach using the annotation, could you please suggest how to achieve that?

Why #RequestBody works without setters?

I am writing a controller with the annotation #RequestBody in order to map to a Java object. The method that uses the annotation is:
#PostMapping("/users")
public ResponseEntity<Object> createUserForProject(#Valid #RequestBody User user) {
log.info("Creating a user " + user.getEmail());
}
This is the User class:
#Getter
#AllArgsConstructor
#Slf4j
#EqualsAndHashCode
#ToString
public class User {
#NotEmpty
#Email
private String email;
#NotEmpty
private String firstName;
#NotEmpty
private String lastName;
#JsonIgnore
private Optional<LocalDate> lastLogonDate = Optional.empty();
#JsonIgnore
private Optional<LocalDate> lastModificationDate = Optional.empty();
#JsonIgnore
private Optional<LocalDate> creationDate = Optional.empty();
#JsonIgnore
private Optional<LocalDate> mfaWarningDate = Optional.empty();
#JsonIgnore
private Optional<LocalDate> auditStartNotificationDate = Optional.empty();
#JsonIgnore
private boolean enabled = true;
public User() {
log.info("HI");
}
(More code without explicit setters)
So when I make a POST call with the body
{
"email":"test#test.com",
"firstName":"testName",
"lastName":"testLastName"
}
Outputs HI and the log with the Creating a user test#test.com message, so the object is created. My point here is... why does this really work? The HttpMessageConverter is calling the no-args constructor and there are no setters to call after create the object with the constructor. How do the object attributes get their values without any setter? What am I missing here?

Spring boot uses Jackson for Object <-> JSON conversion, and Jackson does not need setters, it sets fields via reflection.
Here is a relevant question about Jackson and why it doesn't need setters
How does jackson set private properties without setters?

Custom bean validation

I'm developing an application using spring-boot. I want to validate the user bean using JSR annotation. The problem is that I have some fields that depend on the value of others. For example when status="user_pr" I have to make the address, county, and phoneNumber as mandatory.
this my bean:
#JsonIgnoreProperties(ignoreUnknown = true)
#JsonInclude(JsonInclude.Include.NON_NULL)
public class User {
#NotNull(message = "required")
private String status;
#JsonProperty("first_name")
#NotNull(message = "required")
private String firstName;
#NotNull(message = "required")
private String name;
#NotNull(message = "required")
#Pattern(message = "Email not valid", regexp = "^([\\w\\.\\-_]+)?\\w+#[\\w-_]+(\\.\\w+){1,}$")
private String mailAddress;
private String country;
private String phoneNumber;
#JsonProperty("address")
private Address billingAddress;
}
Would you have any ideas ?
Best regards

I had the same problem a couple of weeks ago, I created my own validation annotation with a custom validation logic. You can find the showcase project in my repository: ConditionalValidator.
If you have any questions, just ask.

How to make input attributes required in post body request?

Here is my example:
Java:
#JsonProperty("id")
private String id;
#JsonProperty(value = "name", required = true)
private String deviceName;
I made the name as a required field. In request how to make it as required field. I should send the name value from request.
But when I enter this:
{ "id": "abc123",}
It should send error response back.
Please help me.

Jacksons JsonProperty Annotation is not used for Validation. see: Jackson #JsonProperty(required=true) doesn't throw an exception. But you can use Bean Validation, e.g.:
class Device {
#JsonProperty("id")
private String id;
#NotEmpty
#JsonProperty(value = "name")
private String deviceName;
}

Only using #JsonIgnore during serialization, but not deserialization

I have a user object that is sent to and from the server. When I send out the user object, I don't want to send the hashed password to the client. So, I added #JsonIgnore on the password property, but this also blocks it from being deserialized into the password that makes it hard to sign up users when they don't have a password.
How can I only get #JsonIgnore to apply to serialization and not deserialization? I'm using Spring JSONView, so I don't have a ton of control over the ObjectMapper.
Things I've tried:
Add #JsonIgnore to the property
Add #JsonIgnore on the getter method only

Exactly how to do this depends on the version of Jackson that you're using. This changed around version 1.9, before that, you could do this by adding #JsonIgnore to the getter.
Which you've tried:
Add #JsonIgnore on the getter method only
Do this, and also add a specific #JsonProperty annotation for your JSON "password" field name to the setter method for the password on your object.
More recent versions of Jackson have added READ_ONLY and WRITE_ONLY annotation arguments for JsonProperty. So you could also do something like:
#JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
private String password;
Docs can be found here.

In order to accomplish this, all that we need is two annotations:
#JsonIgnore
#JsonProperty
Use #JsonIgnore on the class member and its getter, and #JsonProperty on its setter. A sample illustration would help to do this:
class User {
// More fields here
#JsonIgnore
private String password;
#JsonIgnore
public String getPassword() {
return password;
}
#JsonProperty
public void setPassword(final String password) {
this.password = password;
}
}

Since version 2.6: a more intuitive way is to use the com.fasterxml.jackson.annotation.JsonProperty annotation on the field:
#JsonProperty(access = Access.WRITE_ONLY)
private String myField;
Even if a getter exists, the field value is excluded from serialization.
JavaDoc says:
/**
* Access setting that means that the property may only be written (set)
* for deserialization,
* but will not be read (get) on serialization, that is, the value of the property
* is not included in serialization.
*/
WRITE_ONLY
In case you need it the other way around, just use Access.READ_ONLY.

In my case, I have Jackson automatically (de)serializing objects that I return from a Spring MVC controller (I am using #RestController with Spring 4.1.6). I had to use com.fasterxml.jackson.annotation.JsonIgnore instead of org.codehaus.jackson.annotate.JsonIgnore, as otherwise, it simply did nothing.

Another easy way to handle this is to use the argument allowSetters=truein the annotation. This will allow the password to be deserialized into your dto but it will not serialize it into a response body that uses contains object.
example:
#JsonIgnoreProperties(allowSetters = true, value = {"bar"})
class Pojo{
String foo;
String bar;
}
Both foo and bar are populated in the object, but only foo is written into a response body.

"user": {
"firstName": "Musa",
"lastName": "Aliyev",
"email": "klaudi2012#gmail.com",
"passwordIn": "98989898", (or encoded version in front if we not using https)
"country": "Azeribaijan",
"phone": "+994707702747"
}
#CrossOrigin(methods=RequestMethod.POST)
#RequestMapping("/public/register")
public #ResponseBody MsgKit registerNewUsert(#RequestBody User u){
root.registerUser(u);
return new MsgKit("registered");
}
#Service
#Transactional
public class RootBsn {
#Autowired UserRepository userRepo;
public void registerUser(User u) throws Exception{
u.setPassword(u.getPasswordIn());
//Generate some salt and setPassword (encoded - salt+password)
User u=userRepo.save(u);
System.out.println("Registration information saved");
}
}
#Entity
#JsonIgnoreProperties({"recordDate","modificationDate","status","createdBy","modifiedBy","salt","password"})
public class User implements Serializable {
private static final long serialVersionUID = 1L;
#Id
#GeneratedValue(strategy=GenerationType.AUTO)
private Long id;
private String country;
#Column(name="CREATED_BY")
private String createdBy;
private String email;
#Column(name="FIRST_NAME")
private String firstName;
#Column(name="LAST_LOGIN_DATE")
private Timestamp lastLoginDate;
#Column(name="LAST_NAME")
private String lastName;
#Column(name="MODIFICATION_DATE")
private Timestamp modificationDate;
#Column(name="MODIFIED_BY")
private String modifiedBy;
private String password;
#Transient
private String passwordIn;
private String phone;
#Column(name="RECORD_DATE")
private Timestamp recordDate;
private String salt;
private String status;
#Column(name="USER_STATUS")
private String userStatus;
public User() {
}
// getters and setters
}

You can use #JsonIgnoreProperties at class level and put variables you want to igonre in json in "value" parameter.Worked for me fine.
#JsonIgnoreProperties(value = { "myVariable1","myVariable2" })
public class MyClass {
private int myVariable1;,
private int myVariable2;
}

You can also do like:
#JsonIgnore
#JsonProperty(access = Access.WRITE_ONLY)
private String password;
It's worked for me

I was looking for something similar. I still wanted my property serialized but wanted to alter the value using a different getter. In the below example, I'm deserializing the real password but serializing to a masked password. Here's how to do it:
public class User() {
private static final String PASSWORD_MASK = "*********";
#JsonIgnore
private String password;
#JsonProperty(access = JsonProperty.Access.WRITE_ONLY)
public String setPassword(String password) {
if (!password.equals(PASSWORD_MASK) {
this.password = password;
}
}
public String getPassword() {
return password;
}
#JsonProperty("password")
public String getPasswordMasked() {
return PASSWORD_MASK;
}
}

The ideal solution would be to use DTO (data transfer object)

Categories