Microservices in the cloud, part two

Microservices are a hot topic in software design, and for good reason. They have plenty of advantages when it comes to handling infrastructure complexity, many of which were addressed in part one of our related Java post. Now, it’s time to talk about the code and design. In this post, we’ll take a deep dive into each module.

When creating an application, clean code means thinking about design and architecture. Architecture is the software process that handles flexibility, scalability, usability, security, and other points, so you have more time to focus on business rather than on technology. Some architecture examples include:

• Serverless architecture. Application designs that incorporate third-party, Backend-as-a-Service (BaaS) services, and include custom code run in managed, ephemeral containers on a Functions-as-a-Service (FaaS) platform.
• Event-driven architecture. A software architecture pattern promoting the production, detection, consumption of, and reaction to events.
• Microservices architecture. A variant of the service-oriented architecture (SOA) style that structures an application as a collection of loosely coupled services. In a microservices architecture, services are fine grained and the protocols lightweight.

The design has a low-level duty that supervises the code, such as what each module is going to do, the class's scope, the functions proposal, and so on.

• SOLID. The five design principles that make software designs more understandable, flexible, and maintainable.
• Design patterns. The ideal solutions to common problems in software design. Each pattern is like a blueprint you can customize to solve a particular design problem in your code.

Speaker service

The first service that we'll cover is the Speaker service, which uses Thorntail and PostgreSQL. The Eclipse MicroProfile doesn’t have support for a relational database. However, we can use the specification from its older and more mature brother, Jakarta EE. As a first step, let's define the Speaker entity.

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import java.util.Objects;

@Entity
@Table(name = "speaker")
public class Speaker {

	@Id
	@GeneratedValue
	private Integer id;

	@Column
	private String name;

	@Column
	private String bio;

	@Column
	private String twitter;

	@Column
	private String github;

    //more code

}

Revisit our previous article that covers the JPA integration, using Transactional annotation and a CDI Interceptor to manage the transaction.

import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.transaction.Transactional;
import java.util.List;
import java.util.Optional;

@ApplicationScoped
public class SpeakerService {

	@Inject
	private EntityManager entityManager;

	@Transactional
	public Speaker insert(Speaker speaker) {
    	entityManager.persist(speaker);
    	return speaker;
	}

	@Transactional
	public void update(Speaker speaker) {
    	entityManager.persist(speaker);
	}

	@Transactional
	public void delete(Integer id) {
    	find(id).ifPresent(c -> entityManager.remove(c));
	}


	public Optional<Speaker> find(Integer id) {
    	return Optional.ofNullable(entityManager.find(Speaker.class, id));
	}

	public List<Speaker> findAll() {
    	String query = "select e from Speaker e";
    	return entityManager.createQuery(query).getResultList();
	}
}

We have a resource to expose the services through an HTTP request. We've created a layer on DTO to avoid losing the encapsulation.

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.validation.Valid;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static javax.ws.rs.core.Response.Status.NO_CONTENT;
import static javax.ws.rs.core.Response.status;

@Path("speakers")
@RequestScoped
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON+ "; charset=UTF-8")
public class SpeakerResource {

	@Inject
	private SpeakerService speakerService;

	@GET
	public List<SpeakerDTO> findAll() {
    	return speakerService.findAll()
            	.stream().map(SpeakerDTO::of)
            	.collect(Collectors.toList());
	}

	@GET
	@Path("{id}")
	public SpeakerDTO findById(@PathParam("id") Integer id) {
    	final Optional<Speaker> conference = speakerService.find(id);
    	return conference.map(SpeakerDTO::of).orElseThrow(this::notFound);
	}

	@PUT
	@Path("{id}")
	public SpeakerDTO update(@PathParam("id") Integer id, @Valid SpeakerDTO speakerUpdated) {
    	final Optional<Speaker> optional = speakerService.find(id);
    	final Speaker speaker = optional.orElseThrow(() -> notFound());
    	speaker.update(Speaker.of(speakerUpdated));
    	speakerService.update(speaker);
    	return SpeakerDTO.of(speaker);
	}

	@DELETE
	@Path("{id}")
	public Response remove(@PathParam("id") Integer id) {
    	speakerService.delete(id);
    	return status(NO_CONTENT).build();
	}

	@POST
	public SpeakerDTO insert(@Valid SpeakerDTO speaker) {
    	return SpeakerDTO.of(speakerService.insert(Speaker.of(speaker)));
	}

	private WebApplicationException notFound() {
    	return new WebApplicationException(Response.Status.NOT_FOUND);
	}
}

In the .platform.app.yaml file, we need to check that the speaker application has access to the PostgreSQL instance and anything else about the database that lets Platform.sh handle it.

relationships:
  postgresql: "postgresql:postgresql"

Session service

The Session service will handle the contents of the conference, so that a user can find sessions related to topics like cloud and Java. This service uses Elasticsearch with Jakarta NoSQL and KumuluzEE.

import jakarta.nosql.mapping.Column;
import jakarta.nosql.mapping.Entity;
import jakarta.nosql.mapping.Id;

import java.util.Objects;

@Entity
public class Session {

    @Id
    private String id;

    @Column
    private String name;

    @Column
    private String title;

    @Column
    private String description;

    @Column
    private String conference;

    @Column
    private Integer speaker;

}

We're applying a distinct aspect of Elasticsearch to use it as a search engine. Jakarta NoSQL looks to the specialization that allows particular features for each NoSQL database. Therefore, we'll have a mix of repository and ElasticsearchTemplate, a specialty of DocumentTemplate.

import jakarta.nosql.mapping.Repository;

import java.util.List;

public interface SessionRepository extends Repository<Session, String> {

	List<Session> findAll();
}


import org.elasticsearch.index.query.QueryBuilder;
import org.jnosql.artemis.elasticsearch.document.ElasticsearchTemplate;
import org.jnosql.artemis.util.StringUtils;

import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.validation.Valid;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.UUID;
import java.util.logging.Logger;
import java.util.stream.Collectors;

import static javax.ws.rs.core.Response.Status.NO_CONTENT;
import static javax.ws.rs.core.Response.status;
import static org.elasticsearch.index.query.QueryBuilders.boolQuery;
import static org.elasticsearch.index.query.QueryBuilders.termQuery;

@Path("sessions")
@RequestScoped
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON + "; charset=UTF-8")
public class SessionResource {

	private static Logger LOGGER = Logger.getLogger(SessionResource.class.getName());

	@Inject
	private SessionRepository speakerRepository;

	@Inject
	private ElasticsearchTemplate template;

	@GET
	public List<SessionDTO> findAll(@QueryParam("search") String search) {
    	LOGGER.info("searching with the field: " + search);
    	if (StringUtils.isNotBlank(search)) {
        	QueryBuilder queryBuilder = boolQuery()
                	.should(termQuery("name", search))
                	.should(termQuery("title", search))
                	.should(termQuery("description", search));

        	LOGGER.info("the query: " + queryBuilder);
        	List<Session> sessions = template.search(queryBuilder, "Session");
        	LOGGER.info("the result: " + sessions);
        	return sessions.stream()
                	.map(SessionDTO::of)
                	.collect(Collectors.toList());
    	}
    	return speakerRepository.findAll().stream()
            	.map(SessionDTO::of).collect(Collectors.toList());
	}

	@GET
	@Path("{id}")
	public Session findById(@PathParam("id") String id) {
    	final Optional<Session> conference = speakerRepository.findById(id);
    	return conference.orElseThrow(this::notFound);
	}

	@PUT
	@Path("{id}")
	public SessionDTO update(@PathParam("id") String id, @Valid SessionDTO sessionUpdated) {
    	final Optional<Session> optional = speakerRepository.findById(id);
    	final Session session = optional.orElseThrow(() -> notFound());
    	session.update(Session.of(sessionUpdated));
    	speakerRepository.save(session);
    	return SessionDTO.of(session);
	}

	@DELETE
	@Path("{id}")
	public Response remove(@PathParam("id") String id) {
    	speakerRepository.deleteById(id);
    	return status(NO_CONTENT).build();
	}

	@POST
	public SessionDTO insert(@Valid SessionDTO session) {
    	session.setId(UUID.randomUUID().toString());
    	return SessionDTO.of(speakerRepository.save(Session.of(session)));
	}

	private WebApplicationException notFound() {
    	return new WebApplicationException(Response.Status.NOT_FOUND);
	}
}

Conference service

The Conference service is the most connected of the services because it needs to keep information from both speaker and session services. It uses Payara Micro and MongoDB with Jakarta NoSQL.

import jakarta.nosql.mapping.Column;
import jakarta.nosql.mapping.Convert;
import jakarta.nosql.mapping.Entity;
import jakarta.nosql.mapping.Id;

import java.time.Year;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.stream.Collectors;

@Entity
public class Conference {

	@Id
	@Convert(ObjectIdConverter.class)
	private String id;

	@Column
	private String name;

	@Column
	private String city;

	@Column
	private String link;

	@Column
	@Convert(YearConverter.class)
	private Year year;

	@Column
	private List<Speaker> speakers;

	@Column
	private List<Session> sessions;

}

@Entity
public class Session {

	@Column
	private String id;

	@Column
	private String name;
}

@Entity
public class Speaker {

	@Column
	private Integer id;

	@Column
	private String name;

}

One of the benefits of MongoDB is that we can use the subdocument instead of creating a relationship. Therefore, we can embed Speaker and Session instead of doing joins. Note, the Speaker and Session entities have brief information such as name and ID.

import jakarta.nosql.mapping.Repository;

import java.util.List;

public interface ConferenceRepository extends Repository<Conference, String> {

	List<Conference> findAll();
}


import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
import javax.validation.Valid;
import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.WebApplicationException;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;

import static javax.ws.rs.core.Response.Status.NO_CONTENT;
import static javax.ws.rs.core.Response.status;

@Path("conferences")
@RequestScoped
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON+ "; charset=UTF-8")
public class ConferenceResource {

	@Inject
	private ConferenceRepository conferenceRepository;

	@GET
	public List<ConferenceDTO> findAll() {
    	return conferenceRepository.findAll().stream()
            	.map(ConferenceDTO::of)
            	.collect(Collectors.toList());
	}

	@GET
	@Path("{id}")
	public ConferenceDTO findById(@PathParam("id") String id) {
    	final Optional<Conference> conference = conferenceRepository.findById(id);
    	return conference.map(ConferenceDTO::of).orElseThrow(this::notFound);
	}

	@PUT
	@Path("{id}")
	public ConferenceDTO update(@PathParam("id") String id, @Valid ConferenceDTO conferenceUpdated) {
    	final Optional<Conference> optional = conferenceRepository.findById(id);
    	final Conference conference = optional.orElseThrow(() -> notFound());
    	conference.update(Conference.of(conferenceUpdated));
    	conferenceRepository.save(conference);
    	return ConferenceDTO.of(conference);
	}

	@DELETE
	@Path("{id}")
	public Response remove(@PathParam("id") String id) {
    	conferenceRepository.deleteById(id);
    	return status(NO_CONTENT).build();
	}

	@POST
	public ConferenceDTO insert(@Valid ConferenceDTO conference) {
    	return ConferenceDTO.of(conferenceRepository.save(Conference.of(conference)));
	}

	private WebApplicationException notFound() {
    	return new WebApplicationException(Response.Status.NOT_FOUND);
	}
}

Client service

The client will show the RESTful application using HTML 5 with Eclipse Krazo. Yes, Eclipse Krazo has several engine extensions to use more than JSP, such as HTML 5. The extension we'll use is Thymeleaf with Apache TomEE.

	<dependencies>
    	<dependency>
        	<groupId>org.eclipse.microprofile</groupId>
        	<artifactId>microprofile</artifactId>
        	<type>pom</type>
    	</dependency>
    	<dependency>
        	<groupId>sh.platform</groupId>
        	<artifactId>config</artifactId>
    	</dependency>
    	<dependency>
        	<groupId>org.eclipse.krazo</groupId>
        	<artifactId>krazo-core</artifactId>
        	<version>${version.krazo}</version>
    	</dependency>
    	<dependency>
        	<groupId>org.eclipse.krazo</groupId>
        	<artifactId>krazo-cxf</artifactId>
        	<version>${version.krazo}</version>
    	</dependency>
    	<dependency>
        	<groupId>javax.servlet</groupId>
        	<artifactId>jstl</artifactId>
        	<version>${jstl.version}</version>
    	</dependency>
    	<dependency>
        	<groupId>org.eclipse.krazo.ext</groupId>
        	<artifactId>krazo-thymeleaf</artifactId>
        	<version>${version.krazo}</version>
    	</dependency>
	</dependencies>

The first step in the client is to create the bridge to request information from the services. Thankfully, we have an Eclipse MicroProfile Rest Client to deal just with interfaces and nothing more.

package org.jespanol.client.speaker;

import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;

@Path("speakers")
@RegisterRestClient
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON+ "; charset=UTF-8")
public interface SpeakerService {

	@GET
	List<Speaker> findAll();

	@GET
	@Path("{id}")
	Speaker findById(@PathParam("id") Integer id);

	@PUT
	@Path("{id}")
	Speaker update(@PathParam("id") Integer id, Speaker speaker);

	@DELETE
	@Path("{id}")
	Response remove(@PathParam("id") Integer id);

	@POST
	Speaker insert(Speaker speaker);

}


import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;

@Path("sessions")
@RegisterRestClient
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON+ "; charset=UTF-8")
public interface SessionService {

	@GET
	List<Session> findAll(@QueryParam("search") String search);

	@GET
	List<Session> findAll();

	@GET
	@Path("{id}")
	Session findById(@PathParam("id") String id);

	@PUT
	@Path("{id}")
	Session update(@PathParam("id") String id, Session session);

	@DELETE
	@Path("{id}")
	Response remove(@PathParam("id") String id);

	@POST
	Session insert(Session session);

}


import org.eclipse.microprofile.rest.client.inject.RegisterRestClient;

import javax.ws.rs.Consumes;
import javax.ws.rs.DELETE;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.PUT;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;

@Path("conferences")
@RegisterRestClient
@Produces(MediaType.APPLICATION_JSON + "; charset=UTF-8")
@Consumes(MediaType.APPLICATION_JSON+ "; charset=UTF-8")
public interface ConferenceService {

	@GET
	List<Conference> findAll();

	@GET
	@Path("{id}")
	Conference findById(@PathParam("id") String id);

	@PUT
	@Path("{id}")
	Conference update(@PathParam("id") String id, Conference conference);

	@DELETE
	@Path("{id}")
	Response remove(@PathParam("id") String id);

	@POST
	Conference insert(Conference conference);
}

To make sure that the services are up, we conduct an Eclipse Microprofile Health check, so we can evaluate the HTTP status and the response time in milliseconds.

import org.eclipse.microprofile.health.HealthCheck;
import org.eclipse.microprofile.health.HealthCheckResponse;

import javax.ws.rs.client.Client;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

abstract class AbstractHealthCheck implements HealthCheck {


	abstract Client getClient();

	abstract String getUrl();

	abstract String getServiceName();

	@Override
	public HealthCheckResponse call() {
    	try {
        	long start = System.currentTimeMillis();
        	Response response = getClient().target(getUrl()).request(MediaType.TEXT_PLAIN_TYPE)
                	.get();
        	long end = System.currentTimeMillis() - start;
        	return HealthCheckResponse.named(getServiceName())
                	.withData("service", "available")
                	.withData("time millis", end)
                	.withData("status", response.getStatus())
                	.withData("status", response.getStatusInfo().toEnum().toString())
                	.up()
                	.build();
    	} catch (Exception exp) {
        	return HealthCheckResponse.named(getServiceName())
                	.withData("services", "not available")
                	.down()
                	.build();
    	}
	}
}

@Health
@ApplicationScoped
public class ConferenceHealthCheck extends AbstractHealthCheck {

	@Inject
	@ConfigProperty(name = "org.jespanol.client.conference.ConferenceService/mp-rest/url")
	private String url;

	private Client client;

	@PostConstruct
	public void init() {
    	this.client = ClientBuilder.newClient();
	}


	@Override
	Client getClient() {
    	return client;
	}

	@Override
	String getUrl() {
    	return url;
	}

	@Override
	String getServiceName() {
    	return "Conference Service";
	}
}


@Health
@ApplicationScoped
public class SessionHealthCheck extends AbstractHealthCheck {

	@Inject
	@ConfigProperty(name = "org.jespanol.client.session.SessionService/mp-rest/url")
	private String url;

	private Client client;

	@PostConstruct
	public void init() {
    	this.client = ClientBuilder.newClient();
	}


	@Override
	Client getClient() {
    	return client;
	}

	@Override
	String getUrl() {
    	return url;
	}

	@Override
	String getServiceName() {
    	return "Session Service";
	}
}


@Health
@ApplicationScoped
public class SpeakerHealthCheck extends AbstractHealthCheck {

	@Inject
	@ConfigProperty(name = "org.jespanol.client.speaker.SpeakerService/mp-rest/url")
	private String url;

	private Client client;

	@PostConstruct
	public void init() {
    	this.client = ClientBuilder.newClient();
	}

	@Override
	Client getClient() {
    	return client;
	}

	@Override
	String getUrl() {
    	return url;
	}

	@Override
	String getServiceName() {
    	return "Speaker Service";
	}
}

We can access the status at https://server_ip/health.

{
  "checks": [
    {
      "data": {
        "time millis": 11,
        "service": "available",
        "status": "OK"
      },
      "name": "Speaker Service",
      "state": "UP"
    },
    {
      "data": {
        "time millis": 11,
        "service": "available",
        "status": "OK"
      },
      "name": "Conference Service",
      "state": "UP"
    },
    {
      "data": {
        "time millis": 10,
        "service": "available",
        "status": "OK"
      },
      "name": "Session Service",
      "state": "UP"
    }
  ],
  "outcome": "UP",
  "status": "UP"
}

Once Services and health check are ready, let's go to the controllers. Eclipse Krazo is an API built on JAX-RS. Therefore, any Jakarta EE developer will feel at home when creating a Controller class.

import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.jespanol.client.session.SessionService;
import org.jespanol.client.speaker.SpeakerService;

import javax.inject.Inject;
import javax.mvc.Controller;
import javax.mvc.Models;
import javax.mvc.View;
import javax.ws.rs.BeanParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import java.util.Optional;

@Controller
@Path("conference")
public class ConferenceController {
	@Inject
	private Models models;

	@Inject
	@RestClient
	private SessionService sessionService;

	@Inject
	@RestClient
	private ConferenceService conferenceService;

	@Inject
	@RestClient
	private SpeakerService speakerService;

	@GET
	@View("conference.html")
	public void home() {
    	this.models.put("conferences", conferenceService.findAll());
	}


	@Path("add")
	@GET
	@View("conference-add.html")
	public void add() {
    	this.models.put("conference", new Conference());
    	this.models.put("speakers", speakerService.findAll());
    	this.models.put("presentations", sessionService.findAll());
	}

	@Path("delete/{id}")
	@GET
	@View("conference.html")
	public void delete(@PathParam("id") String id) {
    	conferenceService.remove(id);
    	this.models.put("conferences", conferenceService.findAll());
	}

	@Path("edit/{id}")
	@GET
	@View("conference-add.html")
	public void edit(@PathParam("id") String id) {
    	final Conference conference = Optional.ofNullable(conferenceService.findById(id))
            	.orElse(new Conference());
    	this.models.put("conference", conference);
    	this.models.put("speakers", speakerService.findAll());
    	this.models.put("presentations", sessionService.findAll());
	}

	@Path("add")
	@POST
	@View("conference.html")
	public void add(@BeanParam Conference conference) {
    	conference.update(speakerService, sessionService);
    	if (conference.isIdEmpty()) {
        	conferenceService.insert(conference);
    	} else {
        	conferenceService.update(conference.getId(), conference);
    	}
    	this.models.put("conferences", conferenceService.findAll());
	}
}

The HTML5 resource and replacement are on Thymeleaf. We wrote about it in a previous post, Thymeleaf puts the Java instance information on the HTML5 template dynamically.

<!DOCTYPE html>
<html xmlns:th="https://www.thymeleaf.org">
  <html>
    <head>
      <title>Latin America Conf (Session)</title>
      <meta name="viewport" content="width=device-width, initial-scale=1.0" />
      <link rel="stylesheet" href="/css/bootstrap.min.css" />
      <meta charset="UTF-8" />
    </head>
    <body>
      <div class="container">
        <h1>Conference</h1>
        <form
          th:action="@{/conference/add}"
          method="post"
          accept-charset="UTF-8"
        >
          <input id="id" name="id" type="hidden" th:value="${conference.id}" />
          <div class="form-group">
            <label for="conferenceName">Name</label>
            <input
              type="text"
              class="form-control"
              th:value="${conference.name}"
              name="name"
              id="conferenceName"
              placeholder="Enter Session Name"
              required
            />
          </div>
          <div class="form-group">
            <label for="conferenceCity">City</label>
            <input
              type="text"
              class="form-control"
              th:value="${conference.city}"
              name="city"
              id="conferenceCity"
              placeholder="Enter Conference City"
              required
            />
          </div>
          <div class="form-group">
            <label for="conferenceLink">Link</label>
            <input
              type="url"
              class="form-control"
              th:value="${conference.link}"
              name="link"
              id="conferenceLink"
              placeholder="Enter Conference Link"
              required
            />
          </div>
          <div class="form-group">
            <label for="conferenceYear">Year</label>
            <input
              type="number"
              class="form-control"
              th:value="${conference.year}"
              name="year"
              id="conferenceYear"
              placeholder="Enter Conference Year"
              required
            />
          </div>
          <div class="form-group">
            <label for="conferenceSpeakers">Speakers</label>
            <select
              class="form-control"
              id="conferenceSpeakers"
              th:value="${conference.speakersIds}"
              name="speakers"
              multiple
            >
              <tr th:each="speaker : ${speakers}">
                <option
                  th:value="${speaker.id}"
                  th:text="${speaker.name}"
                  th:selected="${conference.speakersIds.contains(speaker.id)}"
                ></option>
              </tr>
            </select>
          </div>
          <div class="form-group">
            <label for="conferenceSpeakers">Sessions</label>
            <select
              class="form-control"
              id="conferenceSessions"
              th:value="${conference.sessionsIds}"
              name="presentations"
              multiple
            >
              <tr th:each="presentation : ${presentations}">
                <option
                  th:value="${presentation.id}"
                  th:text="${presentation.name}"
                  th:selected="${conference.sessionsIds.contains(presentation.id)}"
                ></option>
              </tr>
            </select>
          </div>
          <button type="submit" class="btn">Save</button>
        </form>
      </div>
      <script src="https://code.jquery.com/jquery.js"></script>
      <script src="/js/bootstrap.min.js"></script>
    </body>
  </html>
</html>

Finally, the code

In this post, we finally saw some code and design, which is always exciting! Eclipse MicroProfile has a bright future integrated with Jakarta EE to allow Java developers to create several applications styles—like microservices and monoliths—that use either JPA or NoSQL. Besides that, these projects offer scalability and straightforward Java applications for your business. Platform.sh delivers on the promise of a NoOps pipeline for your Java microservices.