To JPA or not

---
						### software systems be like

![Koszmary architektury](img/koszmary-architektury.jpg)

<div class="source"><p>© mietok - dolny.slask.org.pl (<a href="https://polska-org.pl/900451,foto.html?idEntity=3674117">link</a>)</p></div>
						---
						# why?!

![Layered](img/layered.png)
						---
						```java [3|5-12|14-27|29-40|42-55|68-83|84-88|91-100|103-116|125-139]
						@Named
						@Transactional
						public class Bookingmanagement {

@Value("${client.port}")
						  private int clientPort;

@Value("${server.servlet.context-path}")
						  private String serverContextPath;

@Value("${mythaistar.hourslimitcancellation}")
						  private int hoursLimit;

@Inject
						  private BookingRepository bookingDao;

@Inject
						  private InvitedGuestRepository invitedGuestDao;

@Inject
						  private TableRepository tableDao;

@Inject
						  private Ordermanagement orderManagement;

@Inject
						  private Mail mailService;

@Override
						  public BookingCto findBooking(Long id) {
							LOG.debug("Get Booking with id {} from database.", id);
							BookingEntity entity = getBookingDao().find(id);
							BookingCto cto = new BookingCto();
							cto.setBooking(getBeanMapper().map(entity, BookingEto.class));
							cto.setTable(getBeanMapper().map(entity.getTable(), TableEto.class));
							cto.setOrder(getBeanMapper().map(entity.getOrder(), OrderEto.class));
							cto.setInvitedGuests(getBeanMapper().mapList(entity.getInvitedGuests(), InvitedGuestEto.class));
							cto.setOrders(getBeanMapper().mapList(entity.getOrders(), OrderEto.class));
							return cto;
						  }

@Override
						  public BookingCto findBookingByToken(String token) {
							BookingEntity entity = getBookingDao().findBookingByToken(token);
							BookingCto cto = null;
							if (entity != null) {
							  cto = new BookingCto();
							  cto.setBooking(getBeanMapper().map(entity, BookingEto.class));
							  cto.setTable(getBeanMapper().map(entity.getTable(), TableEto.class));
							  cto.setOrder(getBeanMapper().map(entity.getOrder(), OrderEto.class));
							  cto.setInvitedGuests(getBeanMapper().mapList(entity.getInvitedGuests(), InvitedGuestEto.class));
							  cto.setOrders(getBeanMapper().mapList(entity.getOrders(), OrderEto.class));
							}
							return cto;
						  }

@Override
						  public InvitedGuestEto findInvitedGuestByToken(String token) {
							return getBeanMapper().map(getInvitedGuestDao().findInvitedGuestByToken(token), InvitedGuestEto.class);
						  }

@Override
						  @RolesAllowed(ApplicationAccessControlConfig.PERMISSION_FIND_BOOKING)
						  public Page<BookingCto> findBookingsByPost(BookingSearchCriteriaTo criteria) {
							return findBookingCtos(criteria);
						  }

@Override
						  public Page<BookingCto> findBookingCtos(BookingSearchCriteriaTo criteria) {

Page<BookingCto> pagListTo = null;
							Page<BookingEntity> bookings = getBookingDao().findBookings(criteria);
							List<BookingCto> ctos = new ArrayList<>();
							for (BookingEntity entity : bookings.getContent()) {
							  BookingCto cto = new BookingCto();
							  cto.setBooking(getBeanMapper().map(entity, BookingEto.class));
							  cto.setInvitedGuests(getBeanMapper().mapList(entity.getInvitedGuests(), InvitedGuestEto.class));
							  cto.setOrder(getBeanMapper().map(entity.getOrder(), OrderEto.class));
							  cto.setTable(getBeanMapper().map(entity.getTable(), TableEto.class));
							  cto.setUser(getBeanMapper().map(entity.getUser(), UserEto.class));
							  cto.setOrders(getBeanMapper().mapList(entity.getOrders(), OrderEto.class));
							  ctos.add(cto);
							}
							if (ctos.size() > 0) {
							  Pageable pagResultTo = PageRequest.of(criteria.getPageable().getPageNumber(), ctos.size());
							  pagListTo = new PageImpl<>(ctos, pagResultTo, bookings.getTotalElements());
							}
							return pagListTo;
						  }

@Override
						  public boolean deleteBooking(Long bookingId) {
							List<OrderCto> bookingOrders = this.orderManagement.findOrders(bookingId);
							for (OrderCto orderCto : bookingOrders) {
							  boolean deleteOrderResult = this.orderManagement.deleteOrder(orderCto.getOrder().getId());
							}
							BookingEntity booking = getBookingDao().find(bookingId);
							getBookingDao().delete(booking);
							return true;
						  }

@Override
						  public BookingEto saveBooking(BookingCto booking) {
							Objects.requireNonNull(booking, "booking");
							BookingEntity bookingEntity = getBeanMapper().map(booking.getBooking(), BookingEntity.class);
							bookingEntity.setCanceled(false);
							List<InvitedGuestEntity> invited = getBeanMapper().mapList(booking.getInvitedGuests(), InvitedGuestEntity.class);

for (InvitedGuestEntity invite : invited) {
							try {
								invite.setGuestToken(buildToken(invite.getEmail(), "GB_"));
							} catch (NoSuchAlgorithmException e) {
								LOG.debug("MD5 Algorithm not available at the enviroment");
							}
							invite.setAccepted(false);
							}

bookingEntity.setInvitedGuests(invited);
							try {
								bookingEntity.setBookingToken(buildToken(bookingEntity.getEmail(), "CB_"));
							} catch (NoSuchAlgorithmException e) {
								LOG.debug("MD5 Algorithm not available at the enviroment");
							}

bookingEntity.setCreationDate(Instant.now());
							bookingEntity.setExpirationDate(bookingEntity.getBookingDate().minus(Duration.ofHours(1)));

bookingEntity.setInvitedGuests(getBeanMapper().mapList(invited, InvitedGuestEntity.class));

BookingEntity resultEntity = getBookingDao().save(bookingEntity);
							LOG.debug("Booking with id '{}' has been created.", resultEntity.getId());
							for (InvitedGuestEntity invitedGuest : resultEntity.getInvitedGuests()) {
								invitedGuest.setBookingId(resultEntity.getId());
								InvitedGuestEntity resultInvitedGuest = getInvitedGuestDao().save(invitedGuest);
							}

sendConfirmationEmails(resultEntity);

return getBeanMapper().map(resultEntity, BookingEto.class);
						}

```
						---
						### why layers are challenging?

* simple but does not scale well
						* easy to hack by pushing things up
						* use cases are obscured by trivial pass thru code
						* use cases are obscured by mapping
						* infrastructure layer (DB) leaks to the logic
						---
						#### data access

![ORM](img/orm-basics.png)

* constraints on domain classes
						* technology leaks via annotations
						---
						### even more problematic

lazy loading

```java [1|2-3]
						Order order = entityManager.find(Order.class, 17);
						order.getOrderLines().map(line ->
							item.getPrices().stream().summing(Price::getValue)); // N+1!
						```

implicit updates

```java [1|2]
						order = entityManager.find(Order.class, 17);
						doSomeMagic(order); // one can update and you never know
						```
						---
						#### architecture
						# can we do it

better?
						---
						## hexagonal

![Hexagonal](img/hexagonal.png)
						---
						## dependencies

![Hexagonal deps](img/hexagonal-deps.png)
						---
						### data access adapter

how to implement it?

![Data port and adapter](img/data-port.png)

*inversion of control
						---
						# JPA

shared model or two models?
						---
						### two models

![mapping](img/full-mapping.png)

* extra mapping & more work
						* BUT: clean domain objects
						* BUT: rich domain objects
						* BUT: do DDD freely
						---
						### how to map?

* manually
						* or use Mapstruct, but...
						* don't overdose
						* and know when to stop
						---
						### shared model

![No mapping](img/no-mapping.png)

* simplicity
						* no mappers
						* BUT: tight coupling with tech
						* BUT: how about proxies?
						---
						## can we solve it?

* do not use lazy associations
						* define aggregate boundaries
						* use constructor expressions
						* consider CQRS
						---
						why to use JPA at all?

### there are alternatives

* jOOQ
						* R2DBC
						* JDBI
						---
						### JDBI: simple SELECTs

```java [|2|4|5|6-7]
						public class UserRepository {
						  private final Jdbi jdbi; // <-- inject somehow
						  public List<User> findAllUsers() {
						    return jdbi.withHandle(handle ->
						      handle.createQuery("SELECT id, name FROM users ORDER BY name")
							    .mapToBean(User.class)
								.list();
							}
						  }
						```
						---
						### JDBI: UPDATEs, INSERTs

```java []
						int count = handle.createUpdate(
							"INSERT INTO users(id, name) VALUES (:id, :name)")
								.bind("id", 5)
								.bind("name", "foo")
								.execute();
						```

```java []
						int count = handle.createUpdate(
							"INSERT INTO users(id, name) VALUES (:id, :name)")
								.bindBean(new User(5, "foo")
								.execute();
						```
						---
						### JDBI: SQL Objects

```java []
						interface ManufacturerDao {
							@SqlQuery("SELECT id, name FROM Manufacturers ORDER BY name")
							List<ManufacturerRec> selectAll()

@SqlQuery("SELECT id, name FROM Manufacturers WHERE id=?")
							Optional<ManufacturerRec> selectById(long id)

@SqlUpdate("INSERT INTO Manufacturers (name) VALUES (:name)")
							@GetGeneratedKeys("id")
							long insert(@BindBean ManufacturerRec manufacturer)
						}
						```
						---
						hexagonal

example
						---
						![Booking entity](img/booking.png)

```java [|1-3|5-16|18-20|22-35|37-39|41-43|57-64|66-72]
						@AllArgsConstructor(access = AccessLevel.PRIVATE)
						@Getter
						@Builder
						public final class Booking {
							private final BookingId id;
							private final Instant creationDate;
							private final Instant bookingFromTime;
							private final Instant bookingToTime;
							private final Instant bookingDate;
							private final Instant expirationDate;
							private final String email;
							private int seatsNumber;
							private BookingStatus status;
							private final String token;
							@NonNull
							private final Set<TableBooking> tableBookings;

public static Booking createNewBooking(@NonNull Instant bookingFromTime, @NonNull Instant bookingToTime, @NonNull String email, int seatsNumber) {
								return createNewBooking(null, bookingFromTime, bookingToTime, email, seatsNumber);
							}

public static Booking createNewBooking(BookingId id, @NonNull Instant bookingFromTime, @NonNull Instant bookingToTime, @NonNull String email, int seatsNumber) {
								final Instant now = Instant.now();
								final Duration expiry = Duration.ofDays(1);
								final Instant bookingDate = bookingFromTime.truncatedTo(ChronoUnit.DAYS);
								if (bookingToTime.isBefore(bookingFromTime)) {
									throw new BookingValidationException(String.format("The booking time is invalid, end time %2$s precedes start time %1$s.", bookingFromTime, bookingToTime));
								}
								if (bookingFromTime.isBefore(now.plus(expiry))) {
									throw new BookingValidationException(String.format("The booking date %s is too late to do the booking for given time.", bookingDate));
								}

return createNewBooking(id, now, bookingFromTime, bookingToTime, bookingDate, bookingDate.minus(expiry), email, seatsNumber, BookingStatus.NEW,
										buildToken(email, "CB_"));
							}

public boolean isPersisted() {
								return id != null;
							}

public boolean containsTable(@NonNull TableId tableId) {
								return findTable(tableId).isPresent();
							}

public Optional<TableBooking> findTable(@NonNull TableId tableId) {
								return tableBookings.stream().filter(tableBooking -> tableId.equals(tableBooking.getTableId())).findFirst();
							}

public Stream<TableId> bookingsAsTableIdStream() {
								return tableBookings.stream().map(TableBooking::getTableId);
							}

public boolean hasSufficientTables() {
								return tableBookings.stream().mapToInt(TableBooking::getSeatsNumber).sum() >= seatsNumber;
							}

public void cancel() {
								if (status == BookingStatus.NEW || status == BookingStatus.CONFIRMED) {
									status = BookingStatus.CANCELLED;
									tableBookings.clear();
								} else {
									throw new IllegalBookingStateException(id, status, BookingStatus.CANCELLED);
								}
							}

public void confirm() {
								if (status == BookingStatus.NEW) {
									status = BookingStatus.CONFIRMED;
								} else {
									throw new IllegalBookingStateException(id, status, BookingStatus.CONFIRMED);
								}
							}

public void addTableBooking(@NonNull Table table) {
								addTableBooking(table.getId(), table.getMaxSeats());
							}

private void addTableBooking(@NonNull TableId tableId, int seatsNumber) {
								if (!isPersisted()) {
									throw new BookingValidationException("The booking must be persisted to add tables to it.");
								}
								if (containsTable(tableId)) {
									throw new BookingValidationException(String.format("The booking %d contains table %d already.", id.getValue(), tableId.getValue()));
								}
								tableBookings.add(TableBooking.createTableBooking(tableId, seatsNumber));
							}
						}
						```
						---
						## a use case
						```java [|4-5|8|9-13|15-18|20|21]
						@AllArgsConstructor
						public class ConfirmBookingUseCase implements ConfirmBookingPort {

private final FindBookingByTokenPort findBookingByTokenPort;
							private final SaveBookingPort saveBookingPort;

@Override
							public void confirm(ConfirmBookingCommand command) {
								final Booking booking = findBookingByTokenPort
									.find(command.getToken())
									.orElseThrow(
										() -> new BookingNotFoundException(
											command.getToken()));

if (!booking.hasSufficientTables()) {
									throw new IncompleteBookingException(
										booking.getId(), "lack of table booking");
								}

booking.confirm();
								saveBookingPort.save(booking);
							}
						}
						```
						---
						## ports
						```java
						public interface FindBookingByTokenPort {
							Optional<Booking> find(String token);
						}
						```
						```java
						public interface SaveBookingPort {
							void save(Booking booking);
						}
						```
						---
						## JDBI adapter
						```java [|4-8|11|12|13-15|17-18|19-20|22-25]
						@AllArgsConstructor
						public class FindBookingByTokenJdbiAdapter implements FindBookingByTokenPort {

private final Jdbi db;
							private final BookingMapper bookingMapper
								= BookingMapper.INSTANCE;
							private final TableBookingMapper tableBookingMapper
								= TableBookingMapper.INSTANCE;

@Override
							public Optional<Booking> find(@NonNull String token) {
								return db.withHandle(handle -> {
									final BookingDao dao = handle.attach(BookingDao.class);
									final TableBookingDao tableBookingDao
										= handle.attach(TableBookingDao.class);

return dao.findBookingByToken(token)
										.map(bookingRecord -> {
											List<TableBookingRecord> tableBookings
											= tableBookingDao.findAllTableBookingsForBooking(bookingRecord.getId());

return bookingMapper.toDomain(bookingRecord,
											tableBookings.stream()
											.map(tableBookingMapper::toDomain)
											.collect(Collectors.toSet()));
									});
								});
							}
						}
						```
						---
						## an SQL object
						```java []
						public interface BookingDao {

@SqlQuery("SELECT * FROM Booking WHERE token=:token")
							@RegisterBeanMapper(BookingRecord.class)
							Optional<BookingRecord> findBookingByToken(
								@Bind("token") String token);

@SqlQuery("SELECT * FROM Booking WHERE id=:id")
							@RegisterBeanMapper(BookingRecord.class)
							Optional<BookingRecord> findBookingById(
								@Bind("id") long id);
						}
						```
						---
						## same in JPA
						```java [|5|10-13]
						@AllArgsConstructor
						public class FindBookingByTokenJpaAdapter
							implements FindBookingByTokenPort {

private final BookingRepository bookingRepository;

private final BookingMapper mapper = BookingMapper.INSTANCE;

@Override
							public Optional<Booking> find(String token) {
								return bookingRepository.findBookingEntityByToken(token)
									.map(mapper::toDomain);
							}
						}

```
						---
						## spring data repository
						```java []
						public interface BookingRepository
							extends CrudRepository<BookingEntity, Long> {

Optional<BookingEntity> findBookingEntityByToken(String token);

@Query(
								"from BookingEntity b left outer join fetch b.tableBookings")
							List<BookingEntity> findBookingsWithTables();
						}
						```
						---
						## a mapper
						```java []
						@Mapper(uses = {TableBookingMapper.class})
						public interface BookingMapper {
							@Mapping(target="id.value", source="id")
							Booking toDomain(BookingEntity bookingEntity);

@Mapping(target="id", source="id.value")
							@Mapping(target="tableBookings", ignore = true)
							void toEntity(Booking booking,
								@MappingTarget BookingEntity bookingEntity);
						}

```
						```java []
						public class TableBookingMapper {
							public TableBooking toDomain(
								TableBookingEntity tableBookingEntity) {
								return TableBooking.builder()
										.tableId(new TableId(
											tableBookingEntity.getTable().getId()))
										.seatsNumber(tableBookingEntity.getSeatsNumber())
										.build();
							}
						}
						```
						---
						### how about transactions?
						```java []
						public interface TransactionPort {
							<T> T inTransaction(TransactionalMapper<T> handler);
							default void withTransaction(TransactionalConsumer consumer) {
								inTransaction(() -> {
									consumer.consume();
									return null;
								});
							}
						}
						```
						```java [|2|3-9]
						public void cancel(CancelBookingCommand command) {
							transactionPort.withTransaction(() -> {
								final Booking booking =
									findBookingByTokenPort.find(command.getToken())
									.orElseThrow(() -> new BookingNotFoundException(
										command.getToken()));
								// ...
								booking.cancel();
								saveBookingPort.save(booking);
							});
						}
						```
						---
						JDBI

```java []
						@AllArgsConstructor
						public class TransactionJdbiAdapter implements TransactionPort {
							private final Jdbi db;
							@Override
							public <T> T inTransaction(TransactionalMapper<T> handler) {
								return db.inTransaction(handle -> handler.accept());
							}
						}
						```

JTA/Spring
						```java []
						@Service
						public class TransactionJtaAdapter implements TransactionPort {
							@Transactional
							public <T> T inTransaction(TransactionalMapper<T> handler) {
								return handler.accept();
							}
							@Transactional
							public void withTransaction(TransactionalConsumer consumer) {
								TransactionPort.super.withTransaction(consumer);
							}
						}
						```
						---
						## summary

* JPA can be tamed (if you know when it fails).
						* Mapping solves most of JPA-related problems.
						* If your app mostly reads or mostly writes, use simple mapper (JDBI).
						* For CRUD-like apps use JPA and shared model.
						* BUT beware: most apps in fact are not CRUDs.
						---
						## thank you & questions

![QR](img/qr.png)

https://maciejmalecki.github.io/to-jpa-or-not/

<hr>

* Twitter: @mmalecki77
						* GitHub: https://github.com/maciejmalecki/
						* backup slides [here](backup.html)