fbpx
What is Asynchronous Messaging Design Pattern?

What is Asynchronous Messaging Design Pattern?

What is Asynchronous Messaging Design Pattern?

Previously we saw about What is Microservice? and the principles followed while developing MSA and the available design patterns. also, we saw an API Gateway design pattern.

Today we will see what is Asynchronous Messaging Design Pattern is.

What is Asynchronous Messaging Design Pattern?

Previously we saw about Chained or Chain of responsibility design pattern which makes the client wait for a long time, It also breaks the chain if any one service goes down and cause a bad experience for the clients.

To avoid such bad experiences for the client, The Asynchronous design pattern can be used, which communicate with the available services using message queue or event driven approach and not sequentially.

Yes, Messaging or events, The Asynchronous design pattern uses the Messaging Queue (MQ) or Event driven like ActiveMQ, RabbitMQ, Kafka and other tools for its communication with other services.

Example:

Consider we have Cart, Product, Stock, Order & Shipping services.

When the Product is added to the Cart, Stock must be updated accordingly, So the Product calls stock via Message Queue.

And then Order calls shipment via Message Queue to prepare a label for shipment.

This way the client need not wait for the flow of service to be completed to get the response immediately.

what is Asynchronous design pattern?

 

In the next article, we will see Shared Database or Shared Data design pattern.

 

LIKE | SHARE | SUBSCRIBE

WeCanCode-Author

WeCanCode-Author

November 11, 2021

Senior Developer | Java & C#.NET | 10++ years of IT experience.

Planning to learn ReactJS or Angular or Flutter.!

What is API Gateway Design Pattern?

What is API Gateway Design Pattern?

What is API Gateway Design Pattern?

Previously we saw about What is Microservice? and the principles followed while developing MSA and the available design patterns. also we saw an Aggregator design pattern.

Today we will see what is API Gateway Design Pattern is.

What is API Gateway Design Pattern?

Microservice is built in such a way that each service acts differently on its own. So, when a web application is drilled down into smaller pieces there could be problems we face.

The problems are as follows.

  1. How to get data from various microservices?
  2. A different front-end application is required to manage the same database, just that it uses multiple web services.
  3. How to respond with the data for different consumer to satisfy their requirement. So that we can have reusable microservices.
  4. Handle multiple protocol requests.

Seems the list is small here, but in reality, it is even wider. The solution for these problems is to use the API Gateway design pattern. The API Gateway design pattern addresses many other problems apart from the ones mentioned above. We can also use this design pattern as a proxy service for routing the request.

 API Gateway acts as the entry point for all the endpoints of the microservice, it can help in converting the various protocol request from one type to another. Also, it can disburden the responsibility of authentication/authorization in the microservice.

 So, once the client sends the request, requests are passed through the API gateway which manages the entry point and re-routes the client’s request to the appropriate microservice. Then with the help of the load balancer, it distributes the client’s request to the microservice.

Microservice uses the service discovery which maintains the available microservices and their available entry points to communicate with each other

What is API Gateway Design pattern?

API Gateway Design pattern

 

 

In the next article, we will see Chained or Chain of Responsibility design pattern.

 

LIKE | SHARE | SUBSCRIBE

WeCanCode-Author

WeCanCode-Author

November 06, 2021

Senior Developer | Java & C#.NET | 10++ years of IT experience.

Planning to learn ReactJS or Angular or Flutter.!

Composite Key with JPA and Hibernate

Composite Key with JPA and Hibernate

In this article let discuss on

How to map Composite Key  with JPA and Hibernate

Domain Model

A relational database composite key contains two or more columns which together for the primary key of a given table.

Composite Key with JPA and Hibernate

In the diagram above, the employee table has a Composite Key, which consists of two columns:

    • company_id
    • employee_number

Every Employee can also have a Phone, which uses the same composite key to reference its owning Employee.

Composite Primary Key with JPA and Hibernate

To map this database table mapping, we need to isolate the compound key into an @Embeddable first:

@Embeddable
public class EmployeeId implements Serializable {
 
    @Column(name = "company_id")
    private Long companyId;
 
    @Column(name = "employee_number")
    private Long employeeNumber;
 
    public EmployeeId() {
    }
 
    public EmployeeId(Long companyId, Long employeeId) {
        this.companyId = companyId;
        this.employeeNumber = employeeId;
    }
 
    public Long getCompanyId() {
        return companyId;
    }
 
    public Long getEmployeeNumber() {
        return employeeNumber;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof EmployeeId)) return false;
        EmployeeId that = (EmployeeId) o;
        return Objects.equals(getCompanyId(), that.getCompanyId()) &&
                Objects.equals(getEmployeeNumber(), that.getEmployeeNumber());
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getCompanyId(), getEmployeeNumber());
    }
}

The JPA specification says that all entity identifiers should be serializable and implement equals and hashCode.

So, an Embeddable that is used as a composite identifier must be Serializable and implement equals and hashCode.

The Employee mapping looks as follows:

@Entity(name = "Employee")
@Table(name = "employee")
public class Employee {
 
    @EmbeddedId
    private EmployeeId id;
 
    private String name;
 
    public EmployeeId getId() {
        return id;
    }
 
    public void setId(EmployeeId id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}


The @EmbeddedId is used to instruct Hibernate that theEmployeeentity uses a compound key.

The Phone mapping is rather straightforward as well:

@Entity(name = "Phone")
@Table(name = "phone")
public class Phone {
 
    @Id
    @Column(name = "`number`")
    private String number;
 
    @ManyToOne
    @JoinColumns({
        @JoinColumn(
            name = "company_id",
            referencedColumnName = "company_id"),
        @JoinColumn(
            name = "employee_number",
            referencedColumnName = "employee_number")
    })
    private Employee employee;
 
    public Employee getEmployee() {
        return employee;
    }
 
    public void setEmployee(Employee employee) {
        this.employee = employee;
    }
 
    public String getNumber() {
        return number;
    }
 
    public void setNumber(String number) {
        this.number = number;
    }
}

The Phone uses the number as an entity identifier since every phone number and the @ManyToOne mapping uses the two columns that are part of the compound key.

Mapping relationships using the Composite Key

We can even map relationships using the information provided within the Composite Key itself. In this particular example, the company_id references a Company entity which looks as follows:

@Entity(name = "Company")
@Table(name = "company")
public class Company {
 
    @Id
    private Long id;
 
    private String name;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Company)) return false;
        Company company = (Company) o;
        return Objects.equals(getName(), company.getName());
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getName());
    }
}

We can have the Composite Key mapping referencing the Company entity within the Employee entity:

@Entity(name = "Employee")
@Table(name = "employee")
public class Employee {
 
    @EmbeddedId
    private EmployeeId id;
 
    private String name;
 
    @ManyToOne
    @JoinColumn(name = "company_id",insertable = false, updatable = false)
    private Company company;
 
    public EmployeeId getId() {
        return id;
    }
 
    public void setId(EmployeeId id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

Notice that the @ManyToOne association instructs Hibernate to ignore inserts and updates issued on this mapping since the company_idis controlled by the @EmbeddedId.

 

Mapping a relationships inside @Embeddable

But that’s not all. We can even move the @ManyToOne inside the @Embeddable itself:

@Embeddable
public class EmployeeId implements Serializable {
 
    @ManyToOne
    @JoinColumn(name = "company_id")
    private Company company;
 
    @Column(name = "employee_number")
    private Long employeeNumber;
 
    public EmployeeId() {
    }
 
    public EmployeeId(Company company, Long employeeId) {
        this.company = company;
        this.employeeNumber = employeeId;
    }
 
    public Company getCompany() {
        return company;
    }
 
    public Long getEmployeeNumber() {
        return employeeNumber;
    }
 
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof EmployeeId)) return false;
        EmployeeId that = (EmployeeId) o;
        return Objects.equals(getCompany(), that.getCompany()) &&
                Objects.equals(getEmployeeNumber(), that.getEmployeeNumber());
    }
 
    @Override
    public int hashCode() {
        return Objects.hash(getCompany(), getEmployeeNumber());
    }
}

Now, the Employee mapping will no longer require the extra @ManyToOne association since it’s offered by the entity identifier:

@Entity(name = "Employee")
@Table(name = "employee")
public class Employee {
 
    @EmbeddedId
    private EmployeeId id;
 
    private String name;
 
    public EmployeeId getId() {
        return id;
    }
 
    public void setId(EmployeeId id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
}

The persistence logic changes as follows:

Company company = doInJPA(entityManager -> {
    Company _company = new Company();
    _company.setId(1L);
    _company.setName("vladmihalcea.com");
    entityManager.persist(_company);
    return _company;
});
 
doInJPA(entityManager -> {
    Employee employee = new Employee();
    employee.setId(new EmployeeId(company, 100L));
    employee.setName("Vlad Mihalcea");
    entityManager.persist(employee);
});
 
doInJPA(entityManager -> {
    Employee employee = entityManager.find(
        Employee.class,
        new EmployeeId(company, 100L)
    );
    Phone phone = new Phone();
    phone.setEmployee(employee);
    phone.setNumber("012-345-6789");
    entityManager.persist(phone);
});
 
doInJPA(entityManager -> {
    Phone phone = entityManager.find(Phone.class, "012-345-6789");
    assertNotNull(phone);
    assertEquals(new EmployeeId(company, 100L), phone.getEmployee().getId());
});

Conclusion

Knowing how to map a Composite Key with JPA and Hibernate is very important because this is the way you’d map a many-to-many association.

As demonstrated in this blog post, such a mapping is not complicated at all.

WeCanCode-Author

WeCanCode-Author

August 05, 2021

Java & C#.NET Developer with 10++ years of IT experience.

Planning to learn ReactJS or Angular or Flutter.!

Pin It on Pinterest