DEV Community: Abdelouahedd

Microservices with Spring Boot

Abdelouahedd — Mon, 26 Sep 2022 17:14:47 +0000

Microservices with Spring Boot

In this article we will cover the basic of microservices with spring boot using spring cloud.
I will explain some basic concept of microservice with a small demonstration.

Introduction of microservices :

Microservices mean separate the project to small services,building small,self-contained,ready to run application.
In monolithic architecture we have one project that contains multiple components that becomes a large application that has many disadvantages.
For example, if a monolithic application down, the entire application will be down. Even it’s difficult to maintain a large monolithic application.

Microservices break a large application to different smaller part, so it is easy to detect the problem and maintain it. and also if a component goes down
it will not affect the whole application.

Architecture

Our goal is create microservices that communicate and pass information without intervention.
In the architecture, we create two service customers and invoices using spring boot, those services are communicating via a REST endpoint, and for consuming data as client we use Spring Cloud OpenFeign that create a dynamic implementation of an interface decorated with JAX-RS or Spring MVC annotation.

@FeignClient(name = "CUSTOMER-SERVICE")
public interface CustomerServiceClient {
  @GetMapping("api/customers/{id}")
  Customer getCustomerById(@PathVariable("id") Integer id);

  @GetMapping("api/customers")
  List<Customer> getCustomers();
}

example of OpenFeign client interface for consume the end point of consumer service.
for integrate openFeign we have to add dependency to the project

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

and after that we enable it by using the annotation @EnableFeignClients in a configure class or main class.

@SpringBootApplication
@EnableFeignClients
public class InvoiceApplication {
  public static void main(String[] args) {
    SpringApplication.run(InvoiceApplication.class, args);
  }
}

Applications - Service 1

Customers service created to manage customers of our application, and for that we create a spring boot application using spring initializer, with H2 database with spring Data for manage persist data and spring web for create the end points.

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
      <groupId>com.h2database</groupId>
      <artifactId>h2</artifactId>
      <scope>runtime</scope>
    </dependency>
    <dependency>

and finally we have the service Cutomers

we have to add some configuration propertie to application.yml in ressource folder

server:
  port: 8089
spring:
  application:
    name: CUSTOMER-SERVICE
  h2:
    console:
      enabled: true
  datasource:
    url: jdbc:h2:mem:customer-db
    driverClassName: org.h2.Driver
    username: sa
  jpa:
    database-platform: org.hibernate.dialect.H2Dialect
    hibernate:
      ddl-auto: update
    show-sql: true

we also need some data in our database to retrieve anything with our method above. An embedded database will spin up when the application starts and be destroyed when the application terminates. So, we need to populate the database each time the application starts. We could load in external data each time, but for simplicity/demo purposes, we will create a bean with hard-coded Customer objects to save.

@Bean
  CommandLineRunner commandLineRunner(CustomerService customerService) {
    return arguments -> {
      CustomerRequest customer = CustomerRequest.builder()
        .email("john-doe@gmail.com")
        .firstName("john")
        .lastName("doe")
        .build();
      CustomerRequest customer1 = CustomerRequest.builder()
        .email("Alix-bob@gmail.com")
        .firstName("Bob")
        .lastName("Alix")
        .build();
      Customer customer2 = customerService.saveCustomer(customer);
      Customer customer3 = customerService.saveCustomer(customer1);
      log.info("Saved customer {}", customer2);
      log.info("Saved customer {}", customer3);
    };
  }

A CommandLineRunner runs when the application starts, so this bean executes early in the startup

Applications - Service 2

In Service 2, we have to create same project as customer but we need some other dependency like OpenFeigh client as I munchin in the architecture part.

and again in cutomer service we have to define a cutomer class because we need the frontend application to recognize and map the same objects our backend service uses.

@Getter
@Setter
@ToString
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class Customer {
  private Integer id;
  private String firstName;
  private String lastName;
  private String email;
}

Service2 does not interact directly with the database, so it only needs the domain class to ensure data being passed matches what our backend services expects and returns

Test

AFter creating the two service,
Start each of the applications, either through your IDE or via the command line and we can acces to customer service in http://localhost:8089/api/customers and invoice service by url http://localhost/8081/api/invoices

Service discovery with Eureka servers.

The Discovery server used to register all services after they go to live. Then it will be easy to find out the service from the registry. When a service registers with eureka it will provide the metadata like host, port and health indicator parameters to the client to connect.
We have to create a new service call eureka-server and we have to add dependecy

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

We need to add annotation @EnableEurekaServer to the application main class. This annotation will enable the services registration with the eureka server.

@SpringBootApplication
@EnableEurekaServer
public class EurekaServerApplication {
  public static void main(String[] args) {
    SpringApplication.run(EurekaServerApplication.class, args);
  }
}

Now we need to define some properties to application.properties file.

spring:
  application:
    name: eureka-server
server:
  port: 8761
eureka:
  client:
    fetch-registry: false
    register-with-eureka: false

we set the register-with-eureka to false so that the service euroka not regsiter it self on the discovery.
After we change the application.yml for the cutomers and invoices service and add

    eureka:
    client:
      service-url:
        defaultZone: http://localhost:8761/eureka
      fetch-registry: true
      register-with-eureka: true

so this configuration give the service the ability to register in the discovery euroka.

API Gateway

What’s the real API Gateway meaning? An API gateway is an API management tool that exists between a client and a collection of backend services. An API gateway acts as a reverse proxy to accept all application programming interface (API) calls, aggregate the various services required to fulfil the requests and then return the appropriate result.

The Main Function of an API Gateway!

An API gateway that takes an application user’s request, routes it to one or more backend services, gathers the appropriate data and delivers it to the user in a single, combined package. It also provides analytics, protection against threats and other security for the application.

The primary role of an API Gateway is to act as a single entry point and standardized process for interactions between an organization’s apps, data and services and internal and external customers.

and for have a single entry point to our microservices, we have to create new service spring-boot called gatway-api and add the configuration to register it in the discovery euroka.
For the configuration to blance between service back-end I add the configuration in application.yml file for api-gateway

  cloud:
    gateway:
      discovery:
        locator:
          enabled: true
      routes:
        - id: customer
          uri: lb://CUSTOMER-SERVICE
          predicates:
            - Path=/api/customers/**
          filters:
            - TokenRelay=
        - id: invoice
          uri: lb://INVOICE-SERVICE
          predicates:
            - Path=/api/invoices/**
          filters:
            - TokenRelay=

in the configuration I use the name of services as uri and this example also demonstrates the Spring Cloud Netflix Ribbon load-balancing (defined by the lb prefix on the destination URI)

Authentification

After complete our application and test all the functionallity, we have to secure our ressources by using spring security, in this app I use Oauth2 protocol with Keycloak as ressource server for manage the users of the client and thier authorization

Manage Microservices with Docker Compose

Docker-compose is an orchestration tool that manages containerized applications. For our project, this means we have two high-level steps to get managed microservice containers
- 1. containerize our currently-local applications,
- 2. set up the management layer with Docker Compose.

Docker file

Each service has own docker file for build the image .
example

 FROM maven:3-openjdk-11  as builder
WORKDIR /customer
COPY pom.xml pom.xml
COPY src src
RUN mvn clean package

FROM openjdk:11
COPY --from=builder /customer/target/customer-1.0-SNAPSHOT.jar customer.jar
EXPOSE 8089
CMD ["java", "-jar", "customer.jar"]

docker compose

After create Docker file for each service, We need to create a YAML file with container details, configuration, and commands we want Compose to execute.
At the high level, we will list each of our services, then specify subfields for each. We will also set up a dedicated network for all of the containers to run on, so that way we create app.yml file under docker folder that contains all services of the application and we add new service zipkin for trace all HTTP request.

Schema of the project

links:

github rep
microservice blog
Api gateway

Sending message asynchronously (JSM)

Abdelouahedd — Thu, 10 Mar 2022 16:19:42 +0000

JMS is a Java standard that defines a common API for working with message brokers.

First introduced in 2001, JMS has been the go-to approach for asynchronous messaging
in Java for a very long time.

JSM components :

Jms provide multiple entities :

Jms provider : broker of messages
Jms client : component Jms that can produce or consume a message
Message : Data that can exchange between component Jms

JMS mode comunication :

JMS defines two modes for message delivery:

Point to point : in this mode a message is sent by a producer and is recieved by a single consumer. The support used for the implementation of this mode is the Queue.
Publish/subscribe : in this mode a message is sent by a producer and is reciebed by a single o multiple consumers. The support used for the implementation of this mode is the Topic.

Jms support multiple type of message (Text,Object,Stream octet,Map)

In the schema apove I explain how we can use Jms with activemq as broker

Setting up JMS:

First we have to run a broker in my case I use activeMq
you can download the file zip and after extract the file you can acces to the bin foler and run
```
$ ./activemq console
```
Now we can acces to the web page of activeMq on localhost,
by default activemq use admin as username and password
After config the broker we can now create a spring boot application, and add some essiential dependencies to pom.xml for using jms and activemq

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-activemq</artifactId>
    </dependency>

Property	Description
spring.activemq.broker-url	The URL of the broker
spring.activemq.user	The user for accessing the broker (optional)
spring.activemq.password	The password for accessing the broker (optional)

in the application.yml of spring application we can implement does properties :

  spring:
    activemq:
    broker-url: tcp://127.0.0.1:8161
    user: admin
    password: admin

After config the application we can now sending messages by using JmsTemplate that provide by spring.JmsTemplate eliminates a lot of boiler plate code that would otherwise be required to work with JMS.
JmsTemplate has several methods that are useful for sending messages, including the following:

  // Send raw messages
  void send(MessageCreator messageCreator) throws JmsException;
  void send(Destination destination, MessageCreator messageCreator) throws JmsException;
  void send(String destinationName, MessageCreator messageCreator) throws JmsException;
  // Send messages converted from objects
  void convertAndSend(Object message) throws JmsException;
  void convertAndSend(Destination destination, Object message) throws JmsException;
  void convertAndSend(String destinationName, Object message) throws JmsException;

To use jmsTemplate we can just inject a bean of type JmsTemplate

    @Autowired
    private JmsTemplate jmsTemplate;

and we can create a function to send message :

    public void sendMessage() throws Exception {
          jmsTemplate.convertAndSend("queue.test","Hello world !!");
    }

as we can see in the code we use convertAndSend function to send a message to the queue (destination) queue.test
We can also create Destination by create function in a config class the return bean type Destination

    @Bean
    public Destination destination() {
      return new ActiveMQQueue("queue.test");
    }

After create the bean we can use it in differante component

    @Autowired
    private Destination destination;
    @Autowired
    private JmsTemplate jmsTemplate;

    public void sendMessage() throws Exception {
            jmsTemplate.convertAndSend(destination,"Hello world !!");
    }

Now it came the time to consume our message and we can do it by using jmsTemple with specifique functions that provide for us to recieve a message

    Message receive() throws JmsException;
    Message receive(Destination destination) throws JmsException;
    Message receive(String destinationName) throws JmsException;
    Object receiveAndConvert() throws JmsException;
    Object receiveAndConvert(Destination destination) throws JmsException;
    Object receiveAndConvert(String destinationName) throws JmsException;

The receive() methods receive a raw Message, whereas the receiveAndConvert() methods use a configured message converter to convert messages into domain types.And for each of these, you can specify either a Destination or a String containing the destination name.

    @Autowired
    private Destination destination;
    @Autowired
    private JmsTemplate jmsTemplate;

    public void consumeMessage(Message message) throws Exception {
            Message message = jmsTemplate.receiveAndConvert(destination);
            //...
    }

and we can also use a message listener by annotad a method in a component with @JmsListener.

    @Service
    public class Reciever{
      @JmsListener(destination = "queue.test")
      public void reciever(@Payload Message msg) throws JMSException {
          String message = ((TextMessage) msg).getText();
          System.out.println(message);
      }
    }

The reciever() method is annotated with JmsListener to “listen” for messages on the "queue.test" destination. It doesn’t deal with JmsTemplate, nor is it explicitly invoked by your application code. Instead, framework code within Spring waits for messages to arrive on the specified destination, and when they arrive, the reciever() method is invoked automatically with the message’s Message payload as a parameter.

Run SQL Server in Docker container

Abdelouahedd — Mon, 11 Oct 2021 21:45:37 +0000

SQL server

Sql Server is one of most populare relation database technologie devloped by Microsoft. Its use to store and retrive, it used by applications that support transactional and analytical workloads.

create image for Sql server :

First you must have Docker install in your machine if not check this link :docker

to run sql server create a file named docker-compose.yml in folder of your project

version: "3.3"

services :
  sqldata:
    image: mcr.microsoft.com/mssql/server
    environment:
      - SA_PASSWORD=Pass@word
      - ACCEPT_EULA=Y
    ports:
      - "1433:1433"

To lunch our db, we can run commande from commande line :
$ docker-compose up -d
After docker pullin the image and service run you can check if the information about the image by this commande :
$ docker ps

We can now acces to our container by passing to mode bash of our image :

$ docker exec -it 'name_of_image' 'bash'

After execute the image in mode bash you can connecte to database using sqlcmd :

/opt/mssql-tools/bin/sqlcmd -U SA -P Pass@word

Create your first spring / react application

Abdelouahedd — Sat, 18 Sep 2021 13:49:08 +0000

In this post, we will learn how to create your first web application todo list using spring boot and react js with mysql as database and deployement with docker.
Before begin we should have java 11 or 8 with nodejs installed in our machine.

First we create back end app :

For creating our spring application we can use the web site to init our project : Link
and chose the dependency we want as define in the next picture :

.Lombok :
for use the annotion to create getter,setter and constructors.
.Spring web :
for building a REST FULL api.
.Spring data JPA:
for persisting data to sql using JPA
.Mysql driver :
for connection to database MYSQL

Open the project in our IDE :

I use Intellij IDE , if you want to use eclipse it doesn't matter, just after dowlnload the zip file, extracted and open it in IDE that you use.
After that create 3 packages :

Entitie : adding the entities that will be use to persist data
Repository : adding repository
Service : create our services
Controller : create the controllers for the end point.

Let's create our classes :

Entity

As we know , we want to create a todo list application so we will create a class Todo :

@Entity()
@NoArgsConstructor()
@AllArgsConstructor()
@Getter
@Setter()
@ToString()
public class Todo {
    @Id()
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String task;
    private boolean isCompleted;

    public Todo(String task, boolean isCompleted) {
        this.task = task;
        this.isCompleted = isCompleted;
    }
}

Repository

The repository is Interface implement JpaRepository and have many fonction for persisting data .

@RepositoryRestResource
public interface TodoRepository extends JpaRepository<Todo, Long> {
}

Service

The service represent service layer that contains the application proccessing

@Service
public class TodoService {
    private final TodoRepository todoRepository;

    public TodoService(TodoRepository todoRepository) {
        this.todoRepository = todoRepository;
    }

    public List<Todo> getAllTodos() {
        return todoRepository.findAll();
    }

    public Optional<Todo> getTodo(Long id) {
        return todoRepository.findById(id);
    }

    public Todo UpdateTodo(Long id, Todo todo) {
        todo.setId(id);
        return todoRepository.save(todo);
    }

    public Todo addTodo(Todo todo) {
        return todoRepository.save(todo);
    }

    public void deleteTodo(Long id) {
        todoRepository.deleteById(id);
    }

}

Controller

The controller represente the web layer of application, the class annotaded with @RestController to tell spring container to init the class as class contains the end point for the application .

@CrossOrigin(origins = "*", allowedHeaders = "*")
@RestController
public class TodoRestController {
    private final TodoService todoService;


    public TodoRestController(TodoService todoService) {
        this.todoService = todoService;
    }

    @GetMapping("/listTodos")
    public List<Todo> getAllTodos() {
        return todoService.getAllTodos();
    }

    @GetMapping("/todo/{id}")
    public Todo getTodo(@PathVariable("id") Long id) {
        return todoService.getTodo(id).isPresent() ? todoService.getTodo(id).get() : null;
    }

    @PutMapping("/updateTodo/{id}")
    public Todo UpdateTodo(@PathVariable("id") Long id, @RequestBody Todo todo) {
        todo.setId(id);
        return todoService.UpdateTodo(id, todo);
    }

    @PostMapping("/addTodo")
    public Todo addTodo(@RequestBody Todo todo) {
        return todoService.addTodo(todo);
    }

    @DeleteMapping("/deleteTodo/{id}")
    public void deleteTodo(@PathVariable("id") Long id) {
        todoService.deleteTodo(id);
    }

}

Config data Source

The most popular adventege of spring is autoconfiguration thatway for connecting to the database we must implemnt the properties in application.propertie .

spring.jpa.hibernate.ddl-auto=update
spring.datasource.url=jdbc:mysql://${MYSQL_HOST:localhost}:3306/SPRING_DB
spring.datasource.username=root
spring.datasource.password=root

RUN application

If you use maven in terminal you can run your application using this commande :
mvn spring-boot:run but first create your instance of mysql

Test the application :

For testing our application we can use postman as client :

Add todo :

update todo :

List of todo :

Delete Todo :

for more details :
Github repo

Login using firebase and flutter

Abdelouahedd — Thu, 18 Jun 2020 23:16:58 +0000

In this article, I will show you how to create a login and register in firebase using Flutter.
First , create your project in firebase a,d activate a mode of authentification in firebase auth after configurate your project and put your file google-service.json in the folder app in project.

First we create a model of our user :


class User {
  String _id;
  String username;
  String email;
  String city;
  DateTime birthDay;
  String profileImg;
  String _password;
  double rank;

  User({
    String id,
    this.username,
    this.email,
    String password,
    this.city,
    this.birthDay,
    this.profileImg,
    this.rank = 0,
  })  : _id = id,
        _password = password;

  String get id => _id;

  void setId(String uuid) => _id = uuid;

  String get password => _password;

  factory User.fromRawJson(String str) => User.fromJson(json.decode(str));

  String toRawJson() => json.encode(toJson());

  factory User.fromJson(Map<String, dynamic> json) => User(
        id: json["id"],
        username: json["username"],
        email: json["email"],
        password: json["password"],
        city: json["city"],
        birthDay: (json["birthDay"] as Timestamp).toDate(),
        profileImg: json["profileImg"] == null ? null : json["profileImg"],
        rank: json["rank"],
      );
  Map<String, dynamic> toJson() => {
        "id": id == null ? null : id,
        "username": username,
        "email": email,
        "password": password,
        "city": city,
        "birthDay": birthDay,
        "profileImg": profileImg == null ? null : profileImg,
        "rank": rank,
      };

  @override
  String toString() {
    return """
    User : { \n
      username :  $username - \n
      email : $email - \n
      password : $password  -\n 
      city : $city -\n
      profileImg : $profileImg -\n
      rank : $rank\n
      }\n""";
  }
}

After that we cant create a class that contient our methodes of sign in and sign ou :

class UserController {
  final FirebaseAuth _auth = FirebaseAuth.instance;
  User _user;
  UserController({User user}) : _user = user;

  Future signIn(String email, String password) async {
    try {
      await _auth
          .signInWithEmailAndPassword(email: email, password: password)
          .then((value) => this.getUser(value.user.uid))
          .timeout(new Duration(seconds: 60))
          .catchError(
            (onError) =>
                print("Error while sign in to app :${onError.message}"),
          );
      return _user;
    } catch (e) {
      print("Error while sign in to app :${e.message}");
      return null;
    }
  }

  Future<bool> signOut() async {
    try {
      await _auth.signOut();
      print("Success log out");
      return true;
    } catch (err) {
      print("Error while user sign out  : ${err.message}");
      return false;
    }
  }

  Future getUser(String uid) async {
    await Firestore.instance
        .collection("users")
        .document(uid)
        .get()
        .then((value) => {
              _user = User.fromJson(value.data),
              print("Returned user from getUser ${_user.toString()}")
            })
        .catchError((onError) =>
            print("Error while getting information of user  : $onError"));
  }

}

after creating our logic of controlling data we move to create the UI of login and register:
firstly we create a class of Textfield :

class CustomTextField extends StatelessWidget {
  CustomTextField({
    this.icon,
    this.hint,
    this.obsecure = false,
    this.read = false,
    this.validator,
    this.onSaved,
    this.tap,
    this.textEditingController,
  });
  final FormFieldSetter<String> onSaved;
  final Function tap;
  final Icon icon;
  final String hint;
  final bool obsecure;
  final FormFieldValidator<String> validator;
  final TextEditingController textEditingController;
  final bool read;
  @override
  Widget build(BuildContext context) {
    return Container(
      padding: EdgeInsets.only(left: 20, right: 20, top: 5),
      child: TextFormField(
        readOnly: read,
        controller: this.textEditingController,
        onSaved: onSaved,
        validator: validator,
        autofocus: true,
        obscureText: obsecure,
        onTap: tap,
        style: TextStyle(
          fontSize: 15,
          color: Theme.of(context).primaryColor,
        ),
        decoration: InputDecoration(
            hintStyle: TextStyle(fontSize: 15, color: Colors.blue),
            hintText: hint,
            enabledBorder: OutlineInputBorder(
              borderRadius: BorderRadius.circular(30),
              borderSide: BorderSide(
                color: Theme.of(context).primaryColor,
                width: 2,
              ),
            ),
            border: OutlineInputBorder(
              borderRadius: BorderRadius.circular(30),
              borderSide: BorderSide(
                color: Theme.of(context).primaryColor,
                width: 3,
              ),
            ),
            prefixIcon: Padding(
              child: IconTheme(
                data: IconThemeData(color: Theme.of(context).primaryColor),
                child: icon,
              ),
              padding: EdgeInsets.only(left: 30, right: 10),
            )),
      ),
    );
  }
}

after creating our CustomTextField we can get data from it using the methode onSave and validated using the validator of every filed.

final GlobalKey<FormState> _formKey = GlobalKey<FormState>();
  bool _autoValidate = false;

the _formKey is very important for cheking the state of our form is validated or not .

  Form(
                  key: _formKey,
                  autovalidate: _autoValidate,
                  child: Column(
                    children: [
                      Container(
                        width: MediaQuery.of(context).size.width,
                        child: Column(
                          children: <Widget>[
                            new CustomTextField(
                              icon: Icon(Icons.email),
                              hint: "Email",
                              validator: (v) {
                                Pattern pattern = r'^(([^<>()[\]\\.,;:\s@\"]+'
                                    r'(\.[^<>()[\]\\.,;:\s@\"]+)*)|'
                                    r'(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.'
                                    r'[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)'
                                    r'+[a-zA-Z]{2,}))$';
                                RegExp regex = new RegExp(pattern);
                                if (v.length == 0) return "* require";
                                if (!regex.hasMatch(v))
                                  return 'Enter Valid Email';
                              },
                              onSaved: (newValue) => {
                                _email = newValue,
                                print("New value in email field $newValue"),
                              },
                            ),
                            // Input("Email", Icons.email, 10, emailController),
                            // InputPassword(passwordController, 32),
                            new CustomTextField(
                              icon: Icon(Icons.vpn_key),
                              hint: "Password",
                              obsecure: true,
                              validator: (v) {
                                if (v.length == 0) return "* require";
                                if (v.length < 2)
                                  return 'Password can\'t be less then 6 characteres  ';
                              },
                              onSaved: (newValue) => _password = newValue,
                            ),
                            forgotPassword,
                            SizedBox(
                              height: 25,
                            ),
                            Row(
                              crossAxisAlignment: CrossAxisAlignment.center,
                              mainAxisAlignment: MainAxisAlignment.spaceAround,
                              children: [
                                MyButton("sign in", 3, this.signIn),
                                MyButton("Sign up", 3, this.signUp),
                              ],
                            )
                          ],
                        ),
                      )
                    ],
                  ),
                ),

the fonction for submit our form :
First we check if the form is validate

  bool validateForm() {
    if (!_formKey.currentState.validate()) {
      this.setState(() {
        _autoValidate = true;
      });
      return false;
    }
    return true;
  }

we can use methode for crypting our password :

static String hashPass(String password) {
    var key = utf8.encode("pass@word/user*APP");
    var bytePass = utf8.encode(password);
    var hmacSha256 = new Hmac(sha256, key);
    var hashPass = hmacSha256.convert(bytePass);
    return hashPass.toString();
  }

because when I am register the user I am using this methode
for crypting the password.

 void signIn() {
    final FormState form = _formKey.currentState;

    if (validateForm()) {
      form.save();
      print("$_email -- ${Util.hashPass(this._password)} \n");
      print("$_email -- $_password");
      String hashPassword = Util.hashPass(this._password);
      this.setState(() {
        isLoading = true;
      });
      controller.signIn(_email, hashPassword).then((value) => {
            print("Value retun from signIn methode : $value"),
            if (value == null)
              {
                this.setState(() {
                  isLoading = false;
                }),
                _scaffoldKey.currentState.showSnackBar(
                  SnackBar(
                    backgroundColor: Colors.white,
                    content: new ShowSnackBar(
                      color: Colors.red,
                      msg: "email or password are wrong",
                    ),
                  ),
                ),
              }
            else
              {
                userSession.saveSessionUser(value).then((value) => {
                      print("User saved in sharedRefrences"),
                      this.setState(() {
                        isLoading = false;
                      }),
                      print("User authentified"),
                      sleep(new Duration(milliseconds: 5)),
                      Navigator.push(
                          context, SlideRightRoute(page: ControllerScreens()))
                    }),
              }
          });
    }
  }

DEV Community: Abdelouahedd

**Microservices with Spring Boot**

Microservices with Spring Boot

Introduction of microservices :

Architecture

Applications - Service 1

Applications - Service 2

Test

Service discovery with Eureka servers.

API Gateway

The Main Function of an API Gateway!

Authentification

Manage Microservices with Docker Compose

Docker file

docker compose

Schema of the project

links:

Sending message asynchronously (JSM)

JSM components :

JMS mode comunication :

Setting up JMS:

Run SQL Server in Docker container

SQL server

create image for Sql server :

Create your first spring / react application

First we create back end app :

Open the project in our IDE :

Let's create our classes :

Entity

Repository

Service

Controller

Config data Source

RUN application

Test the application :

Add todo :

update todo :

List of todo :

Delete Todo :

Login using firebase and flutter

Microservices with Spring Boot