name

email

subject

message

consent


Fill the form below to get in touch with me.


Let's hear from you

I'm a Moroccan, officially graduated computer science state engineer
from [The National School of Applied Sciences in Safi, Morocco](http://www.ensas.uca.ma/#/), Currently occupying a
Software engineer and a junior solution architect at the [International Innovation Platform](http://www.iip.ma/).

I got more than three years of experience in making java web applications and ecosystems (ERPs, CRMs, etc.) using the
different **Spring Framework** tools such as **Spring Boot, Spring Data, Spring Cloud**, and many more. In addition to
building powerful user interfaces using **Angular Framework** and **ReactJS** in terms of user experience and
performance. I'm also very passionate about mobile applications; I started my journey with building **Android** apps
with Java; I try some hybrid dev using React Native and Ionic; now, I think **Flutter** is my thing.

> **The only way to predict the future is to code it** ✨

*Let's say blogging for me is the best way to discuss my binary journey !*

Let's get to know me

About Me


Thank you for contacting me! I will get back in touch with you soon.

**Have a great day!**

Thank You!

I'm Elattar Saad, a Moroccan Software Solutions Engineer. I create code and I blog the process !

Home

https://miro.medium.com/max/1400/1*XyC623VATBBN9MeAEREYBw.jpeg

Like everyone I’ve been amazed by what the digital world is made of, and what it can offer us as an added value to our daily life. Don’t get me wrong I’m still amazed even as a senior computer engineering student.
I’m a Moroccan youngster who always had a dream of becoming a computer scientist, my first most real step was joining the Higher School of Technology in Essaouira, yes, where the journey started.
I mainly address my talk to the newbies, computer engineering students and whoever wants to follow this path :

## 1. It's not easy


 <img src="https://miro.medium.com/max/1106/1*5yhLO0nrd2Xsto__tM9s6A.jpeg">


Demotivating you guys will never be my intention, but all I’m saying here: you’ll face some obstacles and it’s normal as one of my professors used to say:

> If it was easy, everybody would be doing it

## 2. Always know that you know nothing


 <img src="https://miro.medium.com/max/1000/1*3Q3sKj5Dmzg3OQGhVWtTLQ.gif">


Always remember, whatever level you are, whatever knowledge you have, **you still don’t know a thing**, you must always have that hunger for more, it’s never enough, it’s never satisfying, the **passion** and the **curiosity** are what going to make you **excel**!

> One thing only I know, and that is that I know nothing — Socrates

## 3. You will lose it


 <img src="https://miro.medium.com/max/1400/0*pHDi2wkvsUNO-IeR">


The journey of a student, generally, will surely have some moments of **loneliness**, sometimes you **lose your guiding light** and sometimes you lose even the passion to do things you **love**, that’s totally normal, and that’s why you should take a **break** from time to another, **you’re not a robot, do sports, go on a trip or even watch a movie then you’ll have it back**.

## 4. Never compare yourself with others

Comparing yourself with others is a **double-edged sword**, it may build you up as it may destroy you down, I choose **not**.

It’s good to look up to people but you always have to keep in mind what they had to sacrifice in the process.

One more thing about this, you're different it must be your way of doing things.

## 5. Your circle is important

The lone wolf methodology mainly won’t help you in your journey, your **friends** are a very important factor in your progress, choose them **carefully** so they will be one of your **boosters**.

## 6. Professors are only there to guide you

Learning things by **yourself** is exactly what is going to make a difference, you must not wait for the school to give it all to you, once you know the way, the searching for information should be yours to do.

## Finally,

I want you to know that as long as you love what you do you’ll be doing just great !


 <img src="https://miro.medium.com/max/1400/0*pHDi2wkvsUNO-IeR">


More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/6-things-to-know-as-a-fresh-it-student-24h" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

6 things to know as a fresh IT student

https://insource.io/images/posts/spring-boot.png

Getting started with Spring Boot: Creating a simple movies list API.

https://miro.medium.com/max/1400/1*PVpPIhlR-iCLFWfdsuD9kg.jpeg

We all had and will surely have moments of uncertainty and completely suffering under the weight of the logical/technical problem we must handle.
Okay, let’s start with this, YOU ARE NOT THE ONLY ONE WHO SUFFERS, WE ALL DO, the only difference is how often you get this, and how strong you become handling it over and over.

I still remember my second internship as a software developer, I was a part of the team charged with building the mobile app version using react native, guess what? I don’t even master vanilla javascript nor how to build a mobile application! And let’s say I was completely screwed 'cause I had only 45 days to deliver the final version of something I had no idea about.

What I’m saying here is not a new framework to master, but also a new design thinking to adapt, a new structure to set, and definitely a new solution to provide.

That’s one of the situations I love and appreciate, yes! you read that right, that’s a golden opportunity to upgrade your set of skills and open up to new technical points of view.
Now, Let’s start with what I did and let us just skip the self-doubt moments 😁.

## 1. Divide and conquer

 <img src="https://miro.medium.com/max/1400/1*PpUgUCH7FIvGqeOIkRl-Uw.jpeg">


What you need to know, is the problem you’re dealing with is a strong opponent to be handled at once and fully, and the best way to win the game is to turn it into a set of small problems that you will handle one by one.

In my case here, is to turn my big problem, being overwhelmed with all this new stuff into these tiny fries:
- Getting into mobile development and think like a mobile developer.
- Mastering JavaScript as fast as possible and go after the web version of React (ReactJS) so I can understand its mobile version (React native).
- Checking out lot of open-sourced react projects so I’ll have an idea of how things are actually being done by professionals.
- Last and not least, getting to know the dev environment requirements and setup mine properly.

If you feel like you need to, divide each one of these as well.

## 2. Go old school

 <img src="https://miro.medium.com/max/960/1*XSpDrVMoMHvgyE5b60_0OA.gif">


It's a wonderful habit to go for a pen and paper when your brain can no longer visualize things properly.
Instead of having that badly-crafted net of thoughts in your mind, why just make them real in a couple of notes and diagrams.

Nevertheless, there're tools to help you get the job done:

### For diagrams and drawings :

[Draw.io](https://app.diagrams.net/) : For designing your charts properly.


 <img src="https://miro.medium.com/max/1400/1*XLsRRViEUA2mSLC2plnB5w.png">


### For notes :

I used to use [One Note](https://www.onenote.com/) and it’s really amazing !


 <img src="https://miro.medium.com/max/1400/1*izKZcrDlgMp6aHyQTvyAaA.jpeg">


Since I switched to MacOs and iOS, I'm using [Apple Note](https://www.icloud.com/notes), it's simple and classy !


 <img src="https://miro.medium.com/max/1400/1*pQddpCd69VswKURa9jUBpg.jpeg">


### And something really helpful :
I got this idea while watching a med doctor performing an autopsy and recording a vocal report in the process.
You can use any **voice record** application to store your ideas, the best about this is that your feelings are stored too, so record them with **passion** and **excitement**!

## 3. Make use of your superpowers


 <img src="https://miro.medium.com/max/1400/1*HvlyDLkHH-6jWOyvvYwebQ.png">


You have those, but not all the time!

While relaxed, we intend to think very clearly, and our brains work just magically.
Yes, I’m talking about that shower time, bathroom time, or maybe that night walk time when your brain can make wonderful blueprints.

While having a similar problem, I intend to have showers, sometimes 3 per day, night walks alone, or you’ll find me just laying down on my bed, thinking deeply of what needs to be done.

**Don’t waste that on drama or some uselessness!**

## 4. It is what it is


 <img src="https://miro.medium.com/max/996/1*eV2eKRRYfL8w2N6kb8HWew.gif">


Sometimes, in order to handle a problem, you first need to clear your mind. In other words, you need to forget about it **temporarily** and don't give a damn for the moment.

But remember you only do that to give yourself a break from that emotional pressure, **so be careful, without your control, it can turn into a lifetime break**!

## 5. Get some help


 <img src="https://miro.medium.com/max/1400/1*kK-lsl-38LYGHi3__t3DSw.jpeg">


It may be a one-person job, still, you can have someone who’ll have your back.

Sometimes the job is confidential and should not be shared, but I’m not talking technically, I have **friends** who help me bear the pain, for that I’m grateful, **emotional support** is way more important than technical.

**Make sure you surround yourself with worthy people!**


## Finally,

I’d like to say, having problems like these, doesn’t mean you’re dumb or stupid, doesn’t mean you made the wrong choice, it only means that you got yourself into a new situation, and you need to adapt to it.

### Learn, adapt and overcome, remember?

More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/lost-in-binaries-here-s-what-i-do-1b1a" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Lost in binaries? Here’s what I do!

Micro-services are all good until they come with their distributed challenges which normally we don't face in monolithic based applications. Just like this one! 

## Understanding the problem

In order to fully get the main purpose of the solution let us first understand the underlying problem.


 <img src="/images/spring/spring-cloud-eureka-problem.svg">


As the diagram above shows, we have to micro-services communicating via a certain network:
- Micro-service I with the IP address **10.10.10.10**, and port **8080**
- Micro-service II with the IP address **20.20.20.20**, and port **8090**

All working peacefully until the second micro-service changed its address and port for some reason.


 <img src="/images/spring/spring-cloud-eureka-problem-2.svg">


As result the micro-service I cannot communicate with micro-service II since it doesn't have the new address and port (30.30.30.30:5000).
To resolve this we need to provide **manually** the micro-service I with the micro-service II's new address and port. **What if we can do that automatically?**

The answer is YES, and that's exactly what Netflix Eureka does.

## Eureka under the hood

The first thing MS2 will do is to register to the naming registry server (Eureka server) providing mainly its IP, port and status (UP or DOWN). [A]

Before MS1 makes the call to MS2 [D], it will fetch the MS2 coordinates from the naming registry [B] which will allow the communication to happen even if MS2 changes its location a million times as long as its registers to the Eureka server. The server will respond with the required data. [C]

You should also understand that by fetching the naming registry or registering to it, the micro-service becomes its client (Eureka client).


 <img src="/images/spring/spring-cloud-eureka-problem-3.svg">


## Let's talk code

For this tutorial I'll be using:

Spring Boot 2.6.2
```xml
<parent>
 <groupId>org.springframework.boot</groupId>
 <artifactId>spring-boot-starter-parent</artifactId>
 <version>2.6.2</version>
 <relativePath/> 
</parent>
```

Java 8 && Spring cloud 2021.0.0 

```xml
<properties>
 <java.version>1.8</java.version>
 <spring-cloud.version>2021.0.0</spring-cloud.version>
</properties>
```

and of course the dependency management for the spring cloud modules

```xml
<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>${spring-cloud.version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
</dependencyManagement>
```

### Eureka server configuration

The Eureka server require the Spring Cloud starter netflix eureka server dependency

```xml
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>
```

Then, we need a set of properties as the following

```yml
# Setting a name for out app
spring:
 application:
 name: registry-server

# Simply telling Eureka server to NOT fetch or register to any server since it's not a client.
eureka:
 client:
 register-with-eureka: false
 fetch-registry: false
```
Finally, we need to declare our app as a registry service using the `@EnableEurekaServer` annotation:

```
@SpringBootApplication
@EnableEurekaServer
public class RegistryEurekaServerApplication {

 public static void main(String[] args) {
 SpringApplication.run(RegistryEurekaServerApplication.class, args);
 }

}
```

You can find a user interface generated by Eureka, for our case is on <a href="localhost:8099">localhost:8099<a>


 <img src="/images/spring/spring-cloud-eureka-dashboard.png">


### Eureka client configuration

The Eureka client require the Spring Cloud starter netflix eureka client dependency

```xml
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>
```
Also for this one, we need a set of properties:

```yml
# Setting a name for out app
spring:
 application:
 name: registry-eureka-client

eureka:
 client:
 # To register to the eureka server
 registerWithEureka: true

 # To fetch the registry from the eureka server
 fetchRegistry: true

 # The location of the eureka server
 serviceUrl:
 defaultZone: http://localhost:8099/eureka/

 instance:
 # The instance hostname
 hostname: localhost
 
 # The instance unique id
 instanceId: ${eureka.instance.hostname}:${spring.application.name}

 # A bench of health information end-points provided by eureka
 statusPageUrl: http://${eureka.hostname}/
 healthCheckUrl: http://${eureka.hostname}/actuator/health
 secureHealthCheckUrl: http://${eureka.hostname}/actuator/health

```

Finally, we need to declare our app as a discovery client (Eureka client) using the `@EnableDiscoveryClient` annotation:

```java
@SpringBootApplication
@EnableDiscoveryClient
public class RegistryEurekaClientApplication {

 public static void main(String[] args) {
 SpringApplication.run(RegistryEurekaClientApplication.class, args);
 }
}
```

Once, we start our client app, we will notice that it successfully registered to the running eureka server.


 <img src="/images/spring/spring-cloud-eureka-register-1.png">


And on the UI dashboard, you can see this:


 <img src="/images/spring/spring-cloud-eureka-register-2.png">


This may seem **incomplete**, actually it is, since we're not fetching the eureka server for registered service instances and exploit them. That's the main purpose of the next article when we will be doing so using a **reverse proxy** called **Netflix Zuul**.

More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/spring-cloud-introduction-to-service-discovery-using-netflix-eureka-3n7k" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Spring cloud: introduction to service discovery using netflix eureka

/images/spring/spring-internal-ms-communication.png

During the solution architecture phase, especially when we're talking micro-services, we need a sort of internal exchange
of data, they're many tools to do so, such as Spring rest template and web client, but I'm using the one I find the simplest of them all:
Yes, **OpenFeign**!

## Installing OpenFeign

First, we add the OpenFeign dependency (inside the pom.xml file), so it will be imported by Maven (our dependency manager). 

```
<dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-starter-openfeign</artifactId>
 <version>3.1.0</version>
</dependency>

<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.springframework.cloud</groupId>
 <artifactId>spring-cloud-dependencies</artifactId>
 <version>${spring-cloud.version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 </dependencies>
 </dependencyManagement>
```

As you already noticed, we are using a tool which belongs to the spring cloud project, as result, we need to set the Spring cloud version we're using.
In side the properties tag, we'll add both, java and spring cloud versions:

```
<properties>
 <java.version>1.8</java.version>
 <spring-cloud.version>2021.0.0</spring-cloud.version>
</properties>
```

**Please note that I'm using Spring boot version** ```2.6.1``` 
**Also note that I'll be using the [movies project](https://github.com/xrio/spring-boot-movies-api) from the previous articles**

After having all the needed dependencies, we still have to declare our app is using OpenFeign in a certain package.
We decorate our main class with the ```@EnableFeignClients``` with the target package which will have the feign clients.

```
@SpringBootApplication
@EnableFeignClients("io.xrio.movies.controller.client")
public class MoviesApplication {
 ...
}
```

## OpenFeign client implementation

In the the implementation, I will be sending a simple get request to the jsonplaceholder API (acting as the second micro-service) to get a list of posts using OpenFeign:


 <img src="/images/spring/spring-inter-comm-arch.png">


#### Defining our DTO

In order to make use the Json/POJO auto-conversion which Spring Boot offers, we'll be using a DTO to manipulate the received/sent data (posts). 
Inside the controller > dto package, we create the PostDTO.java file:

```java
@Data
public class PostDTO {

 private Long id;
 private Long userId;
 private String title;
 private String body;

}
```

**Note that the structure of the DTO is defined by the response of the jsonplaceholder API.**

Next, we create our post client (feign client), which is going to be like the following:

```
@FeignClient(name = "jsonplaceholder", url = "https://jsonplaceholder.typicode.com/posts")
public interface PostClient {

 @GetMapping
 List<PostDTO> getPosts();

}
```

```@FeignClient``` will declare this interface as a feign client in order to be implemented according to our needs. 
The name attribute mainly useless in this case since we're not addressing the api with a name, but using its url instead. The name is used when a naming registry is integrated (a future article is on the way). 

And just like magic, that's all for our client!

Now we need to call our client and return the response to our user. We'll create a PostController which does just that:

```
@RestController
@RequestMapping("post")
@AllArgsConstructor
public class PostController {

 final PostClient postClient;

 @GetMapping
 public List<PostDTO> getPosts(){
 return postClient.getPosts();
 }


}
```

Finally, that's what you will get when invoking this PostController method:


 <img src="/images/spring/spring-inter-comm.png">


More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/spring-internal-micro-service-driven-communication-5co8" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Spring internal micro-service driven communication

Spring boot optional query params request

/images/spring/spring-optional-params.png

Sometimes the job description forces us into a scenario where the request param (or query params) are not always needed or required. The obvious way to get the job done is to check simply if the param is null or not. Let's try this and another smarter way using Optionals which come with Java since its version 8.


## Method 1: Using required attribute

As simple as the following, we'll set the required attribute to false and check if there's a value in the associated variable: 

```
@GetMapping("/params")
public String getWithParam(@RequestParam(required = false) String name){
 if(name == null){
 return "Hello Anonymous";
 }
 return "Hello "+name;
}
```

## Method 2: Using Java 8 Optionals

This time we'll be doing the same using Optionals:

```
@GetMapping("/params")
public String getWithParam(@RequestParam Optional<String> name){
 if(name.isPresent()){
 return "Hello "+name.get();
 }
 return "Hello Anonymous";
}
```
Or even in an advanced way:
```
@GetMapping("/params")
public String getWithParam(@RequestParam Optional<String> name){
 return "Hello "+ name.orElse("Anonymous");
}
```


More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/spring-boot-optional-request-params-51k3" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Spring Boot optional request params

/images/spring/spring-validation-cover.png

Secure applications follow several security measures during their dev and prod phases, the app entry points are one of the most important parts to secure due to the risk of data injection that may occur. Spring proposes its way of data validation which improves controlling these particular points.

As you've already guessed, this article is about more than just data validation; it's also about bean or custom data structure manipulation, which are two important applicative security features that every developer should be aware of.

Enough introductions, for now, let's start with a global blueprint of what we need to achieve, you need to know that both mechanisms resolve two security vulnerabilities:
- **Injection attacks**
- **Database schema exposure**

Sounds bad right? Well, the solution is actually simpler than you think. First, let's understand both problems before jumping to the solutions.

## Injection attacks
An injection attack is when malicious code is injected into the network and retrieves all of the data from the database and sends it to the attacker.
As you concluded the attack uses the open door of your app to gain all the stored data, and it can disguise, the attack, in many types such as **XSS, SQL, XPath, Template, code, CRLF, LDAP, OS command injections**, and more.
If you're using **ORM operations** you're not totally safe, but you're one step ahead. **The more defenses you raise the better**.

## Database schema exposure
Mainly when this occurs, it doesn't come with a great benefit for the attackers, but it still delivers a piece of valuable information, which is the way you constructed your **schemas, data types, and relations**, in some scenarios it becomes critical.

## Data validation
During this tutorial, we will be based on our last [Movies API](https://github.com/xrio/simple-spring-boot-movies).

First, let's add the Spring boot validation dependency to our pom.xml file.

```
<dependency> 
 <groupId>org.springframework.boot</groupId> 
 <artifactId>spring-boot-starter-validation</artifactId> 
</dependency>
```
Second, we'll enhance our movie model with some validation rules.

```
// other imports
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
@Entity
public class Movie {

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 @NotNull(message = "Id must not be null")
 private Long id;

 @NotBlank(message = "Name must not be blank")
 private String name;

 @NotBlank(message = "Type must not be blank")
 private String type;

 @Min(value = 1, message = "Movies are mainly more than a minute")
 @Max(value = 300, message = "Movies are less than 5 hours")
 private Long duration;

 @NotNull(message = "Release year must not be null")
 private Long releaseYear;

}

```

Third, we alter our controller end points' signatures so they can validate incoming request bodies and throw Exception instead of custom exceptions.

```
package io.xrio.movies.controller;

...

import javax.validation.Valid;

@RestController
@RequestMapping("movie")
@Data
public class MovieController {

 ...

 @PostMapping("/")
 public ResponseEntity<?> save(@Valid @RequestBody Movie movie) throws Exception {
 if (movie == null)
 return ResponseEntity.badRequest().body("The provided movie is not valid");
 return ResponseEntity.status(HttpStatus.CREATED).body(movieService.save(movie));
 }

 @PutMapping("/")
 public ResponseEntity<?> update(@Valid @RequestBody Movie movie) throws Exception {
 if (movie == null)
 return ResponseEntity.badRequest().body("The provided movie is not valid");
 return ResponseEntity.ok().body(movieService.update(movie));
 }

 ...

}

```

The ```@Valid``` makes sure that the incoming body is valid, otherwise a ```MethodArgumentNotValidException``` will be thrown

Obviously, we removed the custom-made exception and replaced it with the ```Exception``` class so the controller won't suppress the exception in the controller layer and let the default exception handler interfere, which will cause a 500 server internal error. Instead, it will be handled by the exception handler we’re about to make.

```
package io.xrio.movies.controller.advice;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.validation.FieldError;
import org.springframework.web.bind.MethodArgumentNotValidException;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseStatus;

import java.util.HashMap;
import java.util.Map;

@ControllerAdvice
public class ValidationExceptionHandler {

 @ExceptionHandler(MethodArgumentNotValidException.class)
 public ResponseEntity<?> handleValidationExceptions(MethodArgumentNotValidException exception) {
 Map<String, String> errors = new HashMap<>();
 exception.getBindingResult().getAllErrors().forEach((error) -> {
 String fieldName = ((FieldError) error).getField();
 String errorMessage = error.getDefaultMessage();
 errors.put(fieldName, errorMessage);
 });
 return ResponseEntity.badRequest().body(errors);
 }
}

```

Just like our previous Movie exception handler, this ```ControllerAdvice``` based handler will target the ```MethodArgumentNotValidException``` type exceptions and resolve them by retrieving the validation violation, wrap it in a response entity and send it back to the user with 400 bad request response code.


 <img src="/images/spring/movie-validation-1.png">


***NOTE: Returning the validation violations to the user is a huge blender, it's like telling a house robber why they failed to rob your own house.***

To counter this, we'll print them on the logs, which are by the way are accessible only to the prod env admins. Our Exception will be like this:

```
import lombok.extern.slf4j.Slf4j;

...

@ControllerAdvice
@Slf4j
public class ValidationExceptionHandler {

 @ExceptionHandler(MethodArgumentNotValidException.class)
 public ResponseEntity<?> handleValidationExceptions(MethodArgumentNotValidException exception) {
 exception.getBindingResult().getAllErrors().forEach((error) -> {
 String fieldName = ((FieldError) error).getField();
 String errorMessage = error.getDefaultMessage();
 log.error(fieldName + ": " + errorMessage);
 });
 return ResponseEntity.badRequest().body("Sorry, that movie you sent sucks :)");
 }
}

```
Sending the same request will result this:


 <img src="/images/spring/movie-validation-2.png">

And only prod env admins can see this:

 <img src="/images/spring/movie-validation-3.png">


The ```@Slf4j``` is a short way using [Lombok](https://projectlombok.org/) to call the logger.

Data validation not only is a layer to counter injection attacks, but it helps keep your data nice and clean.

Since we still exposing our model in our end-points, it's time to change that!

## Data manipulation

### Introduction to the DTOs

The data transfer objects, also known as Value Objects (VOs), will be the ones carrying data between two processes, in our case, it will be their structure that will be exposed instead of the model's.

Our MovieDTO will be like the following:

```
import lombok.Data;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
public class MovieDTO {

 @NotNull(message = "Id must not be null")
 private Long id;

 @NotBlank(message = "Name must not be blank")
 private String name;
 @NotBlank(message = "Type must not be blank")
 private String type;
 @Min(value = 1, message = "Movies are mainly more than a minute")
 @Max(value = 300, message = "Movies are less than 5 hours")
 private Long duration;
 @NotNull(message = "Release year must not be null")
 private Long releaseYear;

}

```

Since the DTOs are the ones to be exposed, we added some validation rules.

***Okay, we have the DTOs exposed, but how are we going to persist data using DTOs?***

***The answer is that DTOs only exist in the controller layer, in other words, we can't use them on the service and repository layers.***

Also means our need for a **conversion mechanism**, yes, we need a ```MovieConverter```.

Let's start with the integration of the [ModelMapper](http://modelmapper.org/getting-started/) dependency which will help convert models and DTO in both ways:


```
<dependency>
	<groupId>org.modelmapper</groupId>
	<artifactId>modelmapper</artifactId>
	<version>2.3.5</version>
</dependency>
```
Then, we add its basic configuration so it will treated as Spring Bean:

```

import org.modelmapper.ModelMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class ModelMapperConfig {
 
 @Bean
 public ModelMapper modelMapper() {
 return new ModelMapper();
 }
}

```

I don't like repeating myself ([DRY priciple](https://en.wikipedia.org/wiki/Don%27t_repeat_yourself)) that's why I always put redundant behavior into generic classes, the ```AbstractConverter``` will do that for us:

```

import java.util.ArrayList;
import java.util.List;

public abstract class AbstractConverter <DM, DTO> {

 public abstract DM convertToDM(DTO dto);

 public abstract DTO convertToDTO(DM dm);

 public List<DM> convertToDMs(List<DTO> dtos) {
 List<DM> dms = new ArrayList<>();
 for (DTO dto : dtos) dms.add(convertToDM(dto));
 return dms;
 }

 public List<DTO> convertToDTOs(List<DM> dms) {
 List<DTO> dtos = new ArrayList<>();
 for (DM dm : dms) dtos.add(convertToDTO(dm));
 return dtos;
 }

}

```
Our ```MovieConverter``` will inherit from the ```AbstractConverter``` with the movie model and DTO as class params.

```
import io.xrio.movies.dto.MovieDTO;
import io.xrio.movies.model.Movie;
import org.modelmapper.ModelMapper;
import org.modelmapper.config.Configuration;
import org.springframework.stereotype.Component;

@Component
public class MovieConverter extends AbstractConverter<Movie, MovieDTO> {

 private final ModelMapper modelMapper;

 public MovieConverter(ModelMapper modelMapper) {
 modelMapper.getConfiguration()
 .setFieldMatchingEnabled(true)
 .setFieldAccessLevel(Configuration.AccessLevel.PRIVATE);
 this.modelMapper = modelMapper;
 }

 @Override
 public Movie convertToDM(MovieDTO movieDTO) {
 return modelMapper.map(movieDTO, Movie.class);
 }

 @Override
 public MovieDTO convertToDTO(Movie movie) {
 return modelMapper.map(movie, MovieDTO.class);
 }
}
```

I decorated the ```MovieConverter``` with the ```@Component``` annotation so it can be injected into the MovieController later.

The model mapper will be configured in the ```MovieConverter``` constructors with a simple configuration, and with the model and DTO having the same fields, the mapping will be possible for now.

Before testing our converter, we need to inject it into the controller, then alter the endpoints so they can handle the DTOs now instead.

```
package io.xrio.movies.controller;

import io.xrio.movies.converter.MovieConverter;
import io.xrio.movies.dto.MovieDTO;
import io.xrio.movies.service.MovieService;
import lombok.Data;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import java.util.List;

@RestController
@RequestMapping("movie")
@Data
public class MovieController {

 final MovieService movieService;
 final MovieConverter movieConverter;

 @PostMapping("/")
 public ResponseEntity<?> save(@Valid @RequestBody MovieDTO movieDTO) throws Exception {
 if (movieDTO == null)
 return ResponseEntity.badRequest().body("The provided movie is not valid");
 return ResponseEntity
 .status(HttpStatus.CREATED)
 .body(movieConverter.convertToDTO(movieService.save(movieConverter.convertToDM(movieDTO))));
 }

 @PutMapping("/")
 public ResponseEntity<?> update(@Valid @RequestBody MovieDTO movieDTO) throws Exception {
 if (movieDTO == null)
 return ResponseEntity.badRequest().body("The provided movie is not valid");
 return ResponseEntity
 .ok()
 .body(movieConverter.convertToDTO(movieService.update(movieConverter.convertToDM(movieDTO))));
 }

 @DeleteMapping("/{id}")
 public ResponseEntity<?> delete(@PathVariable Long id) throws Exception {
 if (id == null)
 return ResponseEntity.badRequest().body("The provided movie's id is not valid");
 return ResponseEntity.ok().body("Movie [" + movieService.delete(id) + "] deleted successfully.");
 }

 @GetMapping("/")
 public ResponseEntity<List<MovieDTO>> findAll() {
 return ResponseEntity.ok().body(movieConverter.convertToDTOs(movieService.findAll()));
 }

}

```

Then we test it!


 <img src="/images/spring/movie-conversion-1.png">


**Great! But it looks the same as before with more code!**

True, so let's play the same game with different rules, the movie model for us now will be different than the DTO in order to protect our API against the database schema exposure:

Some of the movie model fields will be put in an info class that will be embedded in the movie, that way we will change the structure and keep things simple for you.

***NOTE: I removed the model validation because it's no longer used or needed.***

```

import lombok.Data;

import javax.persistence.*;
import javax.validation.Valid;
import javax.validation.constraints.NotNull;

@Data
@Entity
public class Movie {

 @Id
 @GeneratedValue(strategy = GenerationType.SEQUENCE)
 private Long id;

 @Embedded
 private Info info;

}

```

```
import javax.persistence.Embeddable;

@Embeddable
public class Info {

 private String name;
 private String type;
 private Long duration;
 private Long releaseYear;

}

```

We need also to alter our DTO's fields' names so we don't need to add an advanced configuration for the model mapper.

```

import lombok.Data;

import javax.validation.constraints.Max;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;

@Data
public class MovieDTO {

 @NotNull(message = "Id must not be null")
 private Long id;

 @NotBlank(message = "Name must not be blank")
 private String infoName;
 @NotBlank(message = "Type must not be blank")
 private String infoType;
 @Min(value = 1, message = "Movies are mainly more than a minute")
 @Max(value = 300, message = "Movies are less than 5 hours")
 private Long infoDuration;
 @NotNull(message = "Release year must not be null")
 private Long infoReleaseYear;

}

```

And finally testing it.


 <img src="/images/spring/movie-conversion-2.png">


## Finnally 
Data validation and data manipulation can be a greatly valued asset to your API dev and prod, not only enhancing security but also gives you the power to keep your data in shape and to adapt to the users’ requirements without changing your own. 






Find the source code [Here](https://github.com/xrio/simple-spring-boot-movies). 

More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/spring-boot-validation-and-bean-manipulation-1leo" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Spring Boot validation and bean manipulation

https://res.cloudinary.com/practicaldev/image/fetch/s--NNcb7stF--/c_imagga_scale,f_auto,fl_progressive,h_900,q_auto,w_1600/https://thepracticaldev.s3.amazonaws.com/i/kqcla6ngdh5sela8ze3b.jpg

Spring is a common term in the dev community, as a beginner, its wideness may overwhelm you on the first step you take towards it. I'm here to make it simpler.

The Spring Framework is a Java platform application framework and inversion of the control (IoC) container. Any Java program may utilize the framework's fundamental capabilities, however, there are extensions for creating web apps on top of the Java EE platform. [Spring Framework - Wikipedia](https://en.wikipedia.org/wiki/Spring_Framework)










## Why using Spring?
Over the years Spring Framework has proven itself to be :
- **Everywhere**: Developers all across the world rely on Spring's adaptable libraries. Every day, millions of end-users enjoy pleasant experiences from Spring, whether it's streaming TV, online shopping, or a variety of other creative solutions. All of the major tech companies, including Alibaba, Amazon, Google, Microsoft, and others, have contributed to Spring.

- **Flexible**: Spring's extensible and extensive collection of extensions and third-party libraries enable developers to create nearly any application they can imagine. The Inversion of Control (IoC) and Dependency Injection (DI) capabilities of Spring Framework offers the foundation for a diverse collection of features and functionality. Spring offers the tools to let you develop secure, reactive, cloud-based microservices for the web or complicated streaming data flows for the enterprise.

- **Productive**: Spring Boot revolutionizes the way you approach Java programming jobs, greatly simplifying your workflow. Spring Boot makes microservice development a breeze by combining essentials like an application environment and an auto-configured, embedded web server. You can move even quicker by combining Spring Boot with Spring Cloud's extensive collection of supporting libraries, servers, patterns, and templates to quickly deploy complete microservices-based architectures to the cloud.

- **Fast**: By default, Spring provides quick startup, fast shutdown, and efficient execution. For even more efficiency, Spring projects are increasingly using the reactive (nonblocking) programming style. Spring's superpower is developer productivity. Spring Boot makes it easier for developers to create apps with considerably less effort than alternative paradigms. Embedded web servers, auto-configuration, and "fat jars" make it easy to get started, and innovations like Spring DevTools' LiveReload allow developers to iterate quicker than ever before. With the Spring Initializr at start.spring.io, you can even start a new Spring project in seconds.

- **Secure**: Spring has a track record of promptly and properly dealing with security concerns. Spring committers collaborate with security experts to fix and test any identified flaws. Third-party dependencies are also constantly checked, and updates are released on a regular basis to make your data and apps as secure as possible. Spring Security also makes it easy to connect with industry-standard security schemes and offers trustworthy, secure-by-default solutions.

- **Supportive**: Spring's community is vast, international, and varied, encompassing people of all ages and skills, from total beginners to seasoned veterans. You can discover the assistance and resources you need to advance to the next level, no matter where you are on your journey: quickstarts, guides & tutorials, videos, meetings, support, or even formal training and certification.


## What can you do using Spring?

- Microservices [Spring | Microservices](https://spring.io/microservices)
- Reactive systems [Spring | Reactive](https://spring.io/reactive)
- Cloud distributed structures [Spring | Cloud](https://spring.io/cloud) 
- Web applications [Spring | Web Apps](https://spring.io/web-applications) 
- Serverless Applications and Function as a Service (FaaS) [Spring | Serverless](https://spring.io/serverless)
- Event-driven Systems [Spring | Event Driven](https://spring.io/event-driven) 
- Batches and automated tasks. [Spring | Batch](https://spring.io/batch) 


### What requirements I need to have before getting started with Spring.
Generally speaking, you need to have a good knowledge of **Java core**, a basic understanding of **data structures**, **OOP**, **IoC**, and **dependency injection**.
But, you also need to know the basics of the framework you intend to use inside the Spring ecosystem, for example, if you are using **Spring Data JPA** I believe you must know how **JPA** works in the first place.

>**Don't make the beginners' mistake, you don't have to know all about Spring before starting, it always comes piece by piece.**

### Where to start?
As previously said, Spring is a whole ecosystem, it is highly recommended to enter it via the Spring Boot door, to do so I suggest this official article: ​​[Spring | Spring Quickstart Guide](https://spring.io/quickstart) 

You can check my new article on Spring Boot [here](http://elattar.me/posts/getting-started-with-spring-boot-creating-a-simple-movies-list-api/).

### More resources

#### Learning sites

- [**Spring learn**](https://spring.io/learn): The official learning site and also my first direction when I need to look for something concerning Spring.
- [**Baeldung**](https://www.baeldung.com/learn-spring-course): A powerful site that provides devs with a set of informative guides with practical examples following the best practices.
- [**DZone**](https://dzone.com/articles/introducing-spring-boot): DZone provides the information, resources, and tactics that IT professionals require. construct the future Are you a non-member? DZone.com is a prominent provider of information resources for software professionals and one of the world's largest online communities.

#### Youtube Channels

If you prefer videos, there's a lot of YouTube channels which I'm sure you'll find useful :

- [Java Brains](https://www.youtube.com/c/JavaBrainsChannel)
- [Amigoscode](https://www.youtube.com/c/amigoscode)

### Training & certification

In your advanced learning stages, you absolutely need to validate your knowledge, in other words, to certify your assets. Here's all you have to know : [Spring | training](https://spring.io/training)

More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/starting-with-spring-framework-here-s-what-you-need-to-know-md6" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

Starting with Spring? Here's what you need to know

https://miro.medium.com/max/1400/1*joSS2sgajxYjlpuNacLkzA.jpeg

Like everyone I’ve been amazed by what the digital world is made of, and what it can offer us as an added value to our daily life. Don’t get me wrong I’m still amazed even as a senior computer engineering student.
I’m a Moroccan youngster who always had a dream of becoming a computer scientist, my first most real step was joining the Higher School of Technology in Essaouira, yes, where the journey started.
I mainly address my talk to the newbies, computer engineering students and whoever wants to follow this path :

You spent some time as a fresh IT student, had some basics in mind, you even tried to experiment how it works in real projects, but what you still lacking here is the professional experience, trust me I know.

I still remember my first days, looking for internships, I’m not going to lie, it was a taught process, but it could be so much easier with some external help. Here I am giving you what I wish I’ve been told:

## 1.Know what you want
The step towards having a good internship is knowing what field you want, if you’re into web development, for example, you have to focus your energy on web development companies.
Knowing your true desires will guide your search process.

 <img src="https://miro.medium.com/max/1400/1*2gxkQsZIbhSy00LXj4aQCw.gif">



## 2.Know your target 

### Collect their information
After having an idea of what field to target, the next step will be looking for companies in the same field.
You can use whatever search tool you want:
- Social media (I recommend LinkedIn)
- Social contacts (a friend of a friend, your school’s professional network, etc.

But you still want to know what you must collect as valuable information, you need to:
- Obviously, an active contact (an e-mail address or a phone number)
- An idea about what this company do, its projects, its partners and for sure some names (its executive board, its HR manager, its director (or CEO/CTO), etc.)

Another thing, from personal experience, I advise you to apply for small companies’ internships, in these, you will be charged with more tasks so you can gain more experience.

These specifications will help you to establish a connection and will give an idea of what you’ll be asked during the interview (if required).


 <img src="https://miro.medium.com/max/1400/0*iZzti26dftKNQtoy">


### The interview
Sometimes the interview is not required, but you still have to be prepared for anything.

During the interview, you can be asked about every detail in your Curriculum Vitae including your technical/hard skills such as programming languages, technologies and frameworks you’re familiar with, etc., your soft skills such as teamwork, team management, public speaking, etc., professional experience if you have some and hobbies.

But here’s the good news, you have a trump card, which is the information you collected about this company, and which will show how interested and professional are you, especially if what they need is the same you can provide them within your CV.


 <img src="https://miro.medium.com/max/1400/0*msQePCEO2AkxPm1Z">


## 3.Know what you have

For sure you need to know what you do best so you can use as an advantage:

### The Curriculum Vitae
What you have here is literally who you are as a piece of paper, and while you apply your CV should be:
- True: Never lie, or put something you don’t have.
- Dynamic: you can’t use the same CV every time you apply (depends on the company needs and what position you’re applying for), and I said the moment your CV will get attention the company needs intersect with what skills you can offer.

### The motivation letter
You got to know the importance of this document, and it has a huge effect on whatever decision the company will take.

The motivation letter is literally what your intentions are, the reason behind that pushes you to have this internship and mostly what qualifies you to have it and not somebody else.

**Make sure you make your intentions clear**.

### The portfolio
Here’s the thing not required for your first internship, but it will give you a huge boost, it’s kind of here’s my work in real terms, and it better be deployed in a public environment.

### Summary
The internship is your gate to the professional you, it’s the opportunity to improve your skills, work with others and mostly contribute to real projects that will make our daily life even easier.

More articles [Here](https://elattar.me/).

<a href="https://dev.to/xrio/what-about-your-first-it-internship-2305" target=_blank>
 
 <img width=10% src="https://cdn1.iconfinder.com/data/icons/logos-and-brands-3/512/84_Dev_logo_logos-512.png">
 
 React to this article and see more on Dev Community
 
</a>

What about your first IT internship?

**This is a paragraph**. Paragraphs are usually represented in visual media as blocks of text separated from adjacent blocks by blank lines and/or first-line [indentation](https://en.wikipedia.org/wiki/Indentation_(typesetting)), but <abbr title="HyperText Markup Language">HTML</abbr> paragraphs can be any structural grouping of related content, such as images or form fields.

The HTML &lt;h1&gt;–&lt;h6&gt; elements represent six levels of section headings. &lt;h1&gt; is the highest section level and &lt;h6&gt; is the lowest.

# This is an H1

## This is an H2

### This is an H3

#### This is an H4

##### This is an H5

###### This is an H6

Avoid using heading tags to resize text. Instead, use the CSS font-size property. Headings use size to indicate their relative importance, but CSS is preferred for general-purpose resizing.

## Quoting

The HTML blockquote element defines a long block quotation in the HTML document from another source.

>Creativity is allowing yourself to make mistakes. Design is knowing which ones to keep. <cite>― Scott Adams</cite>

A URL for the source of the quotation may be given using the cite attribute, while a text representation of the source can be given using the &lt;cite&gt; element.

<hr />

## Unordered Lists

Groups a collection of items that do not have a numerical ordering, and their order in the list is meaningless.

+ Donec non tortor in arcu mollis feugiat
+ Lorem ipsum dolor sit amet, consectetuer adipiscing elit
+ Donec id eros eget quam aliquam gravida
+ Vivamus convallis urna id felis
+ Nulla porta tempus sapien

## Ordered Lists

Represents a list of items. The only difference from the unordered list is taht the order of the items is meaningful.

1. Donec non tortor in arcu mollis feugiat
2. Lorem ipsum dolor sit amet, consectetuer adipiscing elit
3. Donec id eros eget quam aliquam gravida
4. Vivamus convallis urna id felis
5. Nulla porta tempus sapien

## Code Blocks

```
/* Some example CSS code */
body {
 color: #333;
 font-family: Roboto, Helvetica, Arial, sans-serif;
 line-height: 1.5;
}
```

## Video Embeds

<iframe width="640" height="360" src="https://www.youtube.com/embed/wEG7x7jRhNQ" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture" allowfullscreen></iframe>

## Tables

<div class="responsive-table">
 <table>
 <caption>Simple table with caption and header</caption>
 <thead>
 <tr>
 <th>Column 1</th>
 <th>Column 2</th>
 <th>Column 3</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Row 1, Cell 1</td>
 <td>Row 1, Cell 2</td>
 <td>Row 1, Cell 3</td>
 </tr>
 <tr>
 <td>Row 2, Cell 1</td>
 <td>Row 2, Cell 2</td>
 <td>Row 2, Cell 3</td>
 </tr>
 </tbody>
 </table>
</div>

The style guide provides you with a blueprint of default post and page styles. The style guide is also a great reference for suggested typographic treatment and styles for your content.

Style Guide


Your subscription to **Ampersand Newsletter** has been confirmed.

**Thank you for subscribing!**


Subscribe for new updates