Gyms organization application with spring boot and angular part 2

Getting Started | Building an Application with Spring Boot

---

Build an application gyms with Spring boot and Angular use Jpa

We will continue to complete gym project in this part We are going to added the services, the implements, and controllers

The services

Service Components are the class file which contains @Service annotation. These class files are used to write business logic in a different layer, separated from @RestController class file. The logic for creating a service component class file is shown here

We will create eight interfaces in service package:

-> ArbitrateService.java
-> GymService.java
-> PaymentService.java
-> SportService.java
-> SportsManService.java
-> TrainService.java
-> UserService.java
-> WorktimeService.java

Here, we are creating a service interface

ArbitrateService.java This service interface content two methods addArbitrate and editArbitrate

src/main/java/com/gym/service/ArbitrateService.java):

package com.gym.service;
import com.gym.model.Arbitrate;
import com.gym.model.Gym;

public interface ArbitrateService {
	
 Arbitrate addArbitrateForGym(Arbitrate arbitrate, Gym gym);
	
 Arbitrate editArbitrate(Arbitrate arbitrate, Arbitrate existsArbitrate);	
}

Here, we are creating a service interface

GymService.java This service interface content two methods addGym and editGym

src/main/java/com/gym/service/GymService.java):

package com.gym.service;
import com.gym.model.Gym;

public interface GymService {

	Gym addGym(Gym gym);
	
	Gym editGym(Gym gym, Gym existsGym);
}

Here, we are creating a service interface

PaymentService.java This service interface content two methods addPayment and editPayment

src/main/java/com/gym/service/PaymentService.java):

package com.gym.service;

import com.gym.model.Payment;
import com.gym.model.SportsMan;

public interface PaymentService {

	Payment addPayment(Payment payment, SportsMan sportsMan);
	
	Payment editPayment(Payment payment, Payment existPayment);
	
}

Here, we are creating a service interface

SportService.java This service interface content two methods addSport and editSport

src/main/java/com/gym/service/SportService.java):

package com.gym.service;

import com.gym.model.Gym;
import com.gym.model.Sport;

public interface SportService {

	Sport addSport(Sport sport, Gym gym);
	
	Sport editSport(Sport sport, Sport existSport);	
}

Here, we are creating a service interface

SportsManService.java This service interface content two methods addSportsMan and editSportsMan

src/main/java/com/gym/service/SportsManService.java):

package com.gym.service;
import com.gym.model.SportsMan;

public interface SportsManService {

	SportsMan addSportsMan(SportsMan sportsMan);
	
	SportsMan editSportsMan(SportsMan sportsMan, SportsMan existSportsMan);
}

Here, we are creating a service interface

TrainService.java This service interface content two methods addTrain and editTrain

src/main/java/com/gym/service/TrainService.java):

package com.gym.service;
import com.gym.model.Gym;
import com.gym.model.Train;

public interface TrainService {

	Train addTrainForGym(Train train, Gym gym);
	
	Train editTrain(Train train, Train existsTrain);
}

Here, we are creating a service interface

UserService.java This service interface content five methods addUser, editUser, findUserById, findUserByUsername and deleteUser

src/main/java/com/gym/service/UserService.java):

package com.gym.service;
import java.util.Optional;
import com.gym.model.User;

public interface UserService {
	
  User addUser(User user);
  
  User editUser(User user, Long id);
  
  User findUserById(Long id);
  
  Optional<User> findUserByUsername(String username);
  
  void deleteUser(long id);
}

Here, we are creating a service interface

WorktimeService.java This service interface content two methods addWorktime and editWorktime

src/main/java/com/gym/service/WorktimeService.java):

package com.gym.service;
import com.gym.model.Gym;
import com.gym.model.Worktime;

public interface WorktimeService {
	
  Worktime addWorktimeForGym(Worktime worktime, Gym gym);
  
  Worktime editWorktime(Worktime worktime, Worktime existWorktime, Gym gym); 
}

The Implements

Here we will use the implements for the Strategy pattern is a software design pattern commonly used for developing User interface that divides the related program logic into three interconnected elements.

The class that implements the Interface with @Component and @Transactional annotations is as shown −

We will create eigth classes in impl package;

-> ArbitrateServiceImpl.java
-> GymServiceImpl.java
-> PaymentServiceImpl.java
-> SportServiceImpl.java
-> SportsManImpl.java
-> TrainServiceImpl.java
-> UserServiceImpl.java
-> WorktimeServiceImpl.java

Here, we are creating an implement class

ArbitrateServiceImpl.java In this class we will implement ArbitrateService and @Override the methods addArbitrate and editArbitrate

src/main/java/com/gym/impl/ArbitrateServiceImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.ArbitrateDao;
import com.gym.model.Arbitrate;
import com.gym.model.Gym;
import com.gym.service.ArbitrateService;

@Component
public class ArbitrateServiceImpl implements ArbitrateService {
	
 @Autowired
 private ArbitrateDao arbitrateDao;

 @Override
 public Arbitrate editArbitrate(Arbitrate arbitrate, Arbitrate existArbitrate) {
	existArbitrate.setName(arbitrate.getName());
	return arbitrateDao.save(existArbitrate);
 }

 @Override
 public Arbitrate addArbitrateForGym(Arbitrate arbitrate, Gym gym) {
	gym.addArbitrate(arbitrate);
	return arbitrateDao.save(arbitrate);
 }
}

Here, we are creating an implement classe

GymServiceImpl.java In this class we will implement GymService and @Override the methods addGym and editGym

src/main/java/com/gym/impl/GymServiceImpl.java):

package com.gym.impl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.GymDao;
import com.gym.model.Gym;
import com.gym.service.GymService;

@Component
public class GymServiceImpl implements GymService {
	
 @Autowired
 private GymDao gymDao;
	
 @Override
 public Gym addGym(Gym gym) {
	return gymDao.save(gym);
 }

 @Override
 public Gym editGym(Gym gym, Gym existGym) {
	existGym.setName(gym.getName());
	existGym.setAddress(gym.getAddress());
	existGym.setArea(gym.getArea());
	existGym.setCity(gym.getCity());
	existGym.setLogo(gym.getLogo());
	return gymDao.save(existGym);
 }
}

Here, we are creating an implement classe

PaymentServiceImpl.java In this class we will implement PaymentService and @Override the methods addPayment and editPayemnt

src/main/java/com/gym/impl/PaymentServiceImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.PaymentDao;
import com.gym.model.Payment;
import com.gym.model.SportsMan;
import com.gym.service.PaymentService;

@Component
public class PaymentServiceImpl implements PaymentService {
	
 @Autowired
 private PaymentDao paymentDao;

 @Override
 public Payment addPayment(Payment payment, SportsMan sportsMan) {
	sportsMan.addPayment(payment);
	return paymentDao.save(payment);
 }

 @Override
 public Payment editPayment(Payment payment, Payment existPayment) {
	existPayment.setCost(payment.getCost());
	existPayment.setDate(payment.getDate());
	existPayment.setDuration(payment.getDuration());
	return paymentDao.save(existPayment);
	}
}

Here, we are creating an implement classe

SportServiceImpl.java In this class we will implement SportService and @Override the methods addArbitrate and editArbitrate

src/main/java/com/gym/impl/SportServiceImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.SportDao;
import com.gym.model.Gym;
import com.gym.model.Sport;
import com.gym.service.SportService;

@Component
public class SportServiceImpl implements SportService {
	
 @Autowired
 private SportDao sportDao;

 @Override
 public Sport addSport(Sport sport, Gym gym) {
    gym.addSportForGym(sport);
	return sportDao.save(sport);
 }

 @Override
 public Sport editSport(Sport sport, Sport existSport) {
	existSport.setName(sport.getName());
	existSport.setDescription(sport.getDescription());
	existSport.setPhoto(sport.getPhoto());
	return sportDao.save(existSport);
	}
}

Here, we are creating an implement classe

SportsManImpl.java In this class we will implement SportsManService and @Override the methods addSportsMan and editSportsMan

src/main/java/com/gym/impl/SportsManImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.SportsManDao;
import com.gym.model.SportsMan;
import com.gym.service.SportsManService;

@Component
public class SportsManImpl implements SportsManService {
	
 @Autowired
 private SportsManDao sportsManDao;

 @Override
 public SportsMan addSportsMan(SportsMan sportsMan) {
	return sportsManDao.save(sportsMan);
 }

 @Override
 public SportsMan editSportsMan(SportsMan sportsMan, SportsMan existSportsMan) {
	existSportsMan.setFirstName(sportsMan.getFirstName());
	existSportsMan.setLastName(sportsMan.getLastName());
	existSportsMan.setAge(sportsMan.getAge());
	existSportsMan.setSex(sportsMan.getSex());
	existSportsMan.setAvatar(sportsMan.getAvatar());
	return sportsManDao.save(existSportsMan);
  }
}

Here, we are creating an implement classe

TrainServiceImpl.java In this class we will implement ArbitrateService and @Override the methods addTrain and editTrain

src/main/java/com/gym/impl/TrainServiceImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.TrainDao;
import com.gym.model.Gym;
import com.gym.model.Train;
import com.gym.service.TrainService;

@Component
public class TrainServiceImpl implements TrainService {

 @Autowired
 private TrainDao trainDao;
	
 @Override
 public Train addTrainForGym(Train train, Gym gym) {
   gym.addTrain(train);
   return trainDao.save(train);
 }

 @Override
 public Train editTrain(Train train, Train exisTrain) {
   exisTrain.setName(train.getName());
   return trainDao.save(exisTrain);
 }
}

Here, we are creating an implement classe

UserServiceImpl.java In this class we will implement UserService and @Override the methods addUser, editUser, findUserById, findUserByUsername and deleteUser

src/main/java/com/gym/impl/UserServiceImpl.java):

package com.gym.impl;

import java.util.Optional;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.UserDao;
import com.gym.model.User;
import com.gym.service.UserService;

@Transactional
@Component
public class UserServiceImpl implements UserService {
	
 @Override
 private UserDao userDao;

 @Override
 public User addUser(User user) {
	return userDao.save(user);
 }

 @Override
 public User findUserById(Long id) {
	return userDao.findById(id).orElse(null);
 }

 @Override
 public User editUser(User user, Long id) {
   User exsitUser = userDao.findById(id).orElse(null);
   exsitUser.setUsername(user.getUsername());
   exsitUser.setPassword(user.getPassword());
   exsitUser.setAdmin(user.isAdmin());
   return userDao.save(exsitUser);
 }

 @Override
 public Optional<User> findUserByUsername(String username) {
	 Optional<User> users = userDao.findByUsername(username);
	 return users;
 }

 @Override
 public void deleteUser(long id) {
	User exsitUser = userDao.findById(id).orElse(null);
	userDao.delete(exsitUser);
 }
}

Here, we are creating an implement classe

WorktimeServiceImpl.java In this class we will implement WorktimeService and @Override the methods addWorktime and editWorktime

src/main/java/com/gym/impl/WorktimeServiceImpl.java):

package com.gym.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.gym.dao.WorktimeDao;
import com.gym.model.Gym;
import com.gym.model.Worktime;
import com.gym.service.WorktimeService;

@Component
public class WorktimeServiceImpl implements WorktimeService {
	
 @Autowired
 private WorktimeDao worktimeDao;
	
 @Override
 public Worktime addWorktimeForGym(Worktime worktime, Gym gym) {
	gym.addWorktime(worktime);
	return worktimeDao.save(worktime);
 }

 @Override
 public Worktime editWorktime(Worktime worktime, Worktime existWorktime, Gym gym) {
   existWorktime.setDay(worktime.getDay());
   existWorktime.setTimetable(worktime.getTimetable());
   existWorktime.setEnd(worktime.getEnd());
   existWorktime.setStart(worktime.getStart());
   gym.addWorktime(existWorktime);
   return worktimeDao.save(existWorktime);
 }
}

The manager services

It stands for Implementation. It's a Java convention. Often in java (particularly J2EE) you will get an object from some factory, and then use it. That object's type is often given to you as an interface, so that you don't need to know the actual class, just its methods.

We'll be developing the classes managers services. One possible reason for every service class to have an interface is that it makes interactions with sophisticated frameworks (Spring, JEE) much simpler. This is because Java can simply generate interceptor objects against interfaces.

We will create seven interfaces in manager package:

-> ArbitrateManagerService.java
-> GymManagerService.java
-> PaymentMAnagerService.java
-> SportManagerService.java
-> SportsManagerManService.java
-> TrainManagerService.java
-> WorktimeManagerService.java

Here, we are creating a manager service

ArbitrateManagerService.java In this interface we'll create these Methods addArbitrateForSport, addArbitrateForGym, editArbitrate, deleteArbitrate, findArbitrateById, findArbitratesForSport, findArbitratesForGym, findAllArbitrates

src/main/java/com/gym/manager/ArbitrateManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.ArbitrateDto;

public interface ArbitrateManagerService {
	
	void addArbitrateForSport(long idArbitrate, long idSport);
	
	ArbitrateDto addArbitrateForGym(ArbitrateDto arbitrateDto, long idGym);
	
	ArbitrateDto editArbitrate(ArbitrateDto arbitrateDto, long id);
	
	void deleteArbitrate(long id);
	
	ArbitrateDto findArbitrateById(long id);
	
	List<ArbitrateDto> findArbitratesForSport(long idSport);
	
	List<ArbitrateDto> findArbitratesForGym(long id);
	
	List<ArbitrateDto> findAllArbitrates();
}

Here, we are creating a manager service

GymManagerService.java In this interface we'll create these Methods addGym, editGym, deleteGym, findGymById and findAllGyms

src/main/java/com/gym/manager/GymManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.GymDto;

public interface GymManagerService {

	GymDto addGym(GymDto gymDto);
	
	GymDto editGym(GymDto gymDto, Long id);
	
	void deleteGym(Long id);
	
	GymDto findGymById(Long id);
	
	List<GymDto> findAllGyms();
}

Here, we are creating a manager service

PaymentManagerService.java In this interface we'll create these Methods addPayment, editPayment, deletePayment, findPaymentById and findPaymentsForSportsMan

src/main/java/com/gym/manager/PaymentManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.PaymentDto;

public interface PaymentManagerService {

	PaymentDto addPayment(PaymentDto payment, Long idSportsMan);
	
	PaymentDto editPayment(PaymentDto payment, Long id);
	
	void deletePayment(Long id);
	
	PaymentDto findPaymentById(Long id);
	
	List<PaymentDto> findPaymentsForSportsMan(Long idSportsMan);
}

Here, we are creating a manager service

SportManagerService.java In this interface we'll create these Methods addSportForGym, addSportForSportsMan, editSport, deleteSport, deleteSport, findSportById, findSportsForSportsMan, findSportsForGym and editArbitrate

src/main/java/com/gym/manager/SportManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.SportDto;

public interface SportManagerService {

	SportDto addSportForGym(SportDto sportDto, Long idGym);
	
	void addSportForSportsMan(long idSport, long idSportsMan);
	
	SportDto editSport(SportDto sportDto, Long id);
	
	void deleteSport(Long id);
	
	SportDto findSportById(Long id);
	
	List<SportDto> findSportsForSportsMan(Long idSportsMan);
	
	List<SportDto> findSportsForGym(Long idGym);
}

Here, we are creating a manager service

SportsManManagerService.java In this interface we'll create these Methods addSportsMan, editSportsMan, deleteSportsMan, findSportsManById and findAllSportsMans

src/main/java/com/gym/manager/SportsManManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.SportsManDto;

public interface SportsManManagerService {

	SportsManDto addSportsMan(SportsManDto sportsManDto);
	
	SportsManDto editSportsMan(SportsManDto sportsManDto, Long id);
	
	void deleteSportsMan(Long id);
	
	SportsManDto findSportsManById(Long id);
	
	List<SportsManDto> findAllSportsMans();
}

Here, we are creating a manager service

TrainManagerService.java In this interface we'll create these Methods addArbitrate and editArbitrate

src/main/java/com/gym/manager/TrainManagerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.TrainDto;

public interface TrainManagerService {

	TrainDto addTrainForGym(TrainDto trainDto, long idGym);
	
	void addTrainForSport(long idTrain, long idSport);
	
	TrainDto editTrain(TrainDto trainDto, long id);
	
	void deleteTrain(long id);
	
	TrainDto findTrainById(long id);
	
	List<TrainDto> findAllTrains();
	
	List<TrainDto> findTrainsForSport(long idSport);
	
	List<TrainDto> findTrainsForGym(long idGym);
}

Here, we are creating a manager service

WorktimeManangerService.java In this interface we'll create these Methods addSportsManForWork, addWorktimeForGym, editWorktime, deleteWorktime, findWorktimeById, findWorktimesForGym and findSportsManForWorktime

src/main/java/com/gym/manager/WorktimeManangerService.java):

package com.gym.manager;
import java.util.List;
import com.gym.dto.SportsManDto;
import com.gym.dto.WorktimeDto;

public interface WorktimeManangerService {
	
  void addSportsManForWork(long idSprtsMan, long idWorktime);
	
  WorktimeDto addWorktimeForGym(WorktimeDto worktimeDto, long idGym);
  
  WorktimeDto editWorktime(WorktimeDto worktimeDto, Long id, long idGym);
  
  void deleteWorktime(Long id);
  
  WorktimeDto findWorktimeById(Long id);
  
  List<WorktimeDto> findWorktimesForGym(Long idGym);
  
  List<SportsManDto> findSportsManForWorktime(Long idWorktime);
}

The managers classes Implementation

An impl class is usually a class that implements the behaviour described by one of these interfaces. While the internal implementation class, With transactions configured, we can now annotation a bean with @Transactional and @Service either at the class or method level. Then conversion Entity to DTO. This is stands for Data Transfer Object and is a simple Plain Old Java Object which contains class properties and getters and settings methods for accessing those properties.

We will create seven interfaces in managerImpl package:

-> ArbitrateManagerServiceImpl.java
-> GymManagerServiceImpl.java
-> PaymentManagerServiceImpl.java
-> SportManagerServiceImpl.java
-> SportsManManagerServiceImpl.java
-> TrainManagerServiceImpl.java
-> WorktimeManagerServiceImpl.java

Here, we are creating a manager class impl

ArbitrateManagerServiceImpl.java In this class we'll implementaion ArbitrateManagerService and @Override All methods

src/main/java/com/gym/managerImp/ArbitrateManagerServiceImpl.java):

package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.ArbitrateDao;
import com.gym.dao.GymDao;
import com.gym.dao.SportDao;
import com.gym.dto.ArbitrateDto;
import com.gym.manager.ArbitrateManagerService;
import com.gym.model.Arbitrate;
import com.gym.model.Gym;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.Sport;
import com.gym.service.ArbitrateService;

@Transactional
@Service
public class ArbitrateManagerServiceImpl implements ArbitrateManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private ArbitrateService arbitrateService;
	
 @Autowired
 private SportDao sportDao;
	
 @Autowired
 private ArbitrateDao arbitrateDao;
	
 @Autowired
 private GymDao gymDao;
 
 @Override
 public ArbitrateDto addArbitrateForGym(ArbitrateDto arbitrateDto, long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	Arbitrate arbitrate = orikaBeanMapper.map(arbitrateDto, Arbitrate.class);
	return orikaBeanMapper.convertDTO(arbitrateService.addArbitrateForGym(arbitrate, gym), ArbitrateDto.class);
 }

 @Override
 public ArbitrateDto editArbitrate(ArbitrateDto arbitrateDto, long id) {
	Arbitrate existsArbitrate = arbitrateDao.findById(id).orElse(null);
	Arbitrate arbitrate = orikaBeanMapper.map(arbitrateDto, Arbitrate.class);
	return orikaBeanMapper.convertDTO(
				arbitrateService.editArbitrate(arbitrate, existsArbitrate), ArbitrateDto.class);
 }

 @Override
 public void deleteArbitrate(long id) {
	Arbitrate existsArbitrate = arbitrateDao.findById(id).orElse(null);
	arbitrateService.delete(existsArbitrate);
 }

 @Override
 public ArbitrateDto findArbitrateById(long id) {
	return orikaBeanMapper.convertDTO(arbitrateDao.findById(id).orElse(null), ArbitrateDto.class);
 }

 @Override
 public List<ArbitrateDto> findArbitratesForSport(long idSport) {
	Sport sport = sportDao.findById(idSport).orElse(null);
	List<Arbitrate> arbitrates = sport.getArbitrates();
	return orikaBeanMapper.convertListDTO(arbitrates, ArbitrateDto.class);
 }

 @Override
 public void addArbitrateForSport(long idArbitrate, long idSport) {
	Sport sport = sportDao.findById(idSport).orElse(null);
	Arbitrate arbitrate = arbitrateDao.findById(idArbitrate).orElse(null);
	sport.addArbitrate(arbitrate);
 }

 @Override
 public List<ArbitrateDto> findArbitratesForGym(long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	List<Arbitrate> arbitrates = gym.getArbitrates();
	return orikaBeanMapper.convertListDTO(arbitrates, ArbitrateDto.class);
 }

 @Override
 public List<ArbitrateDto> findAllArbitrates() {
	List<Arbitrate> arbitrates = arbitrateDao.findAll();
	return orikaBeanMapper.convertListDTO(arbitrates, ArbitrateDto.class);
 }

}

Here, we are creating a manager class impl

GymManagerServiceImpl.java In this class we'll implementaion GymManagerService and @Override All methods

src/main/java/com/gym/managerImp/GymManagerServiceImpl.java):

  
package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.GymDao;
import com.gym.dto.GymDto;
import com.gym.manager.GymManagerService;
import com.gym.model.Gym;
import com.gym.model.OrikaBeanMapper;
import com.gym.service.GymService;

@Transactional
@Service
public class GymManagerServiceImpl implements GymManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private GymService gymService;
	
 @Autowired
 private GymDao gymDao;
 
@Override
 public GymDto addGym(GymDto gymDto) {
	Gym gym = orikaBeanMapper.map(gymDto, Gym.class);
	return orikaBeanMapper.convertDTO(gymService.addGym(gym), GymDto.class);
 }

 @Override
 public GymDto editGym(GymDto gymDto, Long id) {
	Gym gym = orikaBeanMapper.map(gymDto, Gym.class);
	Gym existsGym = gymDao.findById(id).orElse(null);
	return orikaBeanMapper.convertDTO(gymService.editGym(gym, existsGym), GymDto.class);
 }

@Override
 public void deleteGym(Long id) {
	Gym existsGym = gymDao.findById(id).orElse(null);
	gymDao.delete(existsGym);
 }

@Override
 public GymDto findGymById(Long id) {
	return orikaBeanMapper.convertDTO(gymDao.findById(id).orElse(null), GymDto.class);
 }

@Override
 public List<GymDto> findAllGyms() {
	List<Gym> gyms = gymDao.findAll();
	return orikaBeanMapper.convertListDTO(gyms, GymDto.class);
 }
}

Here, we are creating a manager class impl

PaymentManagerServiceImpl.java In this class we'll implementaion PaymentManagerService and @Override All methods

src/main/java/com/gym/managerImpl/PaymentManagerServiceImpl.java):

package com.gym.managerImpl;
import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.PaymentDao;
import com.gym.dao.SportsManDao;
import com.gym.dto.PaymentDto;
import com.gym.manager.PaymentManagerService;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.Payment;
import com.gym.model.SportsMan;
import com.gym.service.PaymentService;

@Transactional
@Service
public class PaymentManagerServiceImpl implements PaymentManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private PaymentService paymentService;
	
 @Autowired
 private PaymentDao paymentDao;
	
 @Autowired
 private SportsManDao sportsManDao;
 
 @Override
 public PaymentDto addPayment(PaymentDto paymentDto, Long idSportsMan) {
	SportsMan sportsMan = sportsManDao.findById(idSportsMan).orElse(null);
	Payment payment = orikaBeanMapper.map(paymentDto Payment.class);
	return orikaBeanMapper.convertDTO(paymentService.addPayment(payment, sportsMan), PaymentDto.class);
 }

 @Override
 public PaymentDto editPayment(PaymentDto paymentDto, Long id) {
	Payment payment = orikaBeanMapper.map(paymentDto, Payment.class);
	Payment existsPayment = paymentDao.findById(id).orElse(null);
	return orikaBeanMapper.convertDTO(paymentService.editPayment(payment, existsPayment), PaymentDto.class);
 }

 @Override
 public void deletePayment(Long id) {
	Payment existsPayment = paymentDao.findById(id).orElse(null);
	paymentDao.delete(existsPayment);
		
 }

 @Override
 public PaymentDto findPaymentById(Long id) {
	return orikaBeanMapper.convertDTO(paymentDao.findById(id).orElse(null), PaymentDto.class);
 }

 @Override
 public List<PaymentDto> findPaymentsForSportsMan(Long idSportsMan) {
	SportsMan sportsMan = sportsManDao.findById(idSportsMan).orElse(null);
	List<Payment> payments = sportsMan.getPayments();
	return orikaBeanMapper.convertListDTO(payments, PaymentDto.class);
 }
}

Here, we are creating a manager class impl

SportManagerServiceImpl.java In this class we'll implementaion SportManagerService and @Override All methods

src/main/java/com/gym/managerImpl/SportManagerServiceImpl.java):

package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.GymDao;
import com.gym.dao.SportDao;
import com.gym.dao.SportsManDao;
import com.gym.dto.SportDto;
import com.gym.manager.SportManagerService;
import com.gym.model.Gym;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.Sport;
import com.gym.model.SportsMan;
import com.gym.service.SportService;

@Transactional
@Service
public class SportManagerServiceImpl implements SportManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private SportDao sportDao;
	
 @Autowired
 private SportService sportService;
	
 @Autowired
 private SportsManDao sportsManDao;
	
 @Autowired
 private GymDao gymDao;
 
 @Override
 public SportDto addSportForGym(SportDto sportDto, Long idGym) {
	Sport sport = orikaBeanMapper.map(sportDto, Sport.class);
	Gym gym = gymDao.findById(idGym).orElse(null);
	return orikaBeanMapper.convertDTO(sportService.addSport(sport, gym), SportDto.class);
 }

 @Override
 public SportDto editSport(SportDto sportDto, Long id) {
	Sport sport = orikaBeanMapper.map(sportDto, Sport.class);
	Sport existsSport = sportDao.findById(id).orElse(null);
	return orikaBeanMapper.convertDTO(sportService.editSport(sport, existsSport), SportDto.class);
 }

 @Override
 public void deleteSport(Long id) {
	Sport existsSport = sportDao.findById(id).orElse(null);
	sportDao.delete(existsSport);
 }

 @Override
 public SportDto findSportById(Long id) {
	return orikaBeanMapper.convertDTO(sportDao.findById(id).orElse(null), SportDto.class);
 }

 @Override
 public List<SportDto> findSportsForSportsMan(Long idSportsMan) {
	SportsMan sportsMan = sportsManDao.findById(idSportsMan).orElse(null);
	List<Sport> sports = sportsMan.getSports();
	return orikaBeanMapper.convertListDTO(sports, SportDto.class);
 }

 @Override
 public void addSportForSportsMan(long idSport, long idSportsMan) {
	SportsMan sportsMan = sportsManDao.findById(idSportsMan).orElse(null);
	Sport existsSport = sportDao.findById(idSport).orElse(null);
	sportsMan.addSport(existsSport);
 }

 @Override
 public List<SportDto> findSportsForGym(Long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	List<Sport> sports = gym.getSports();
	return orikaBeanMapper.convertListDTO(sports, SportDto.class);
 }
}

Here, we are creating a manager class impl

SportsManManagerServiceImpl.java In this class we'll implementaion SportsManManagerService and @Override All methods

src/main/java/com/gym/managerImpl/SportsManManagerServiceImpl.java):

package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.SportsManDao;
import com.gym.dto.SportsManDto;
import com.gym.manager.SportsManManagerService;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.SportsMan;
import com.gym.service.SportsManService;

@Transactional
@Service
public class SportsManManagerServiceImpl implements SportsManManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private SportsManDao sportsManDao;
	
 @Autowired
 private SportsManService sportsManService;
 
 @Override
 public SportsManDto addSportsMan(SportsManDto sportsManDto) {
	SportsMan sportsMan = orikaBeanMapper.map(sportsManDto, SportsMan.class);
	return orikaBeanMapper.convertDTO(sportsManService.addSportsMan(sportsMan), SportsManDto.class);
 }

 @Override
 public SportsManDto editSportsMan(SportsManDto sportsManDto, Long id) {
	SportsMan sportsMan = orikaBeanMapper.map(sportsManDto, SportsMan.class);
	SportsMan existSportsMan = sportsManDao.findById(id).orElse(null);
	return orikaBeanMapper.convertDTO(sportsManService.editSportsMan(existSportsMan, sportsMan), SportsManDto.class);
 }

 @Override
 public void deleteSportsMan(Long id) {
	SportsMan existSportsMan = sportsManDao.findById(id).orElse(null);
	sportsManDao.delete(existSportsMan);
 }

 @Override
 public SportsManDto findSportsManById(Long id) {
	return orikaBeanMapper.convertDTO(sportsManDao.findById(id).orElse(null), SportsManDto.class);
 }

 @Override
 public List<SportsManDto> findAllSportsMans() {
	List<SportsMan> sportsMans = sportsManDao.findAll();
	return orikaBeanMapper.convertListDTO(sportsMans, SportsManDto.class);
  }
}

Here, we are creating a manager class impl

TrainManagerServiceImpl.java In this class we'll implementaion TrainManagerService and @Override All methods

src/main/java/com/gym/managerImpl/TrainManagerServiceImpl.java):

package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.GymDao;
import com.gym.dao.SportDao;
import com.gym.dao.TrainDao;
import com.gym.dto.TrainDto;
import com.gym.manager.TrainManagerService;
import com.gym.model.Gym;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.Sport;
import com.gym.model.Train;
import com.gym.service.TrainService;

@Transactional
@Service
public class TrainManagerServiceImpl implements TrainManagerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private TrainDao trainDao;
	
 @Autowired
 private TrainService trainService;
	
 @Autowired
 private SportDao sportDao;
	
 @Autowired
 private GymDao gymDao;
 
 @Override
 public TrainDto addTrainForGym(TrainDto trainDto, long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	Train train = orikaBeanMapper.map(trainDto, Train.class);
	return orikaBeanMapper.convertDTO(trainService.addTrainForGym(train, gym), TrainDto.class);
 }

 @Override
 public TrainDto editTrain(TrainDto trainDto, long id) {
	Train train = orikaBeanMapper.map(trainDto, Train.class);
	Train existsTrain = trainDao.findById(id).orElse(null);
	return orikaBeanMapper.convertDTO(trainService.editTrain(train, existsTrain), TrainDto.class);
 }

 @Override
 public void deleteTrain(long id) {
	Train existsTrain = sportDao.findById(id).orElse(null);
	sportDao.delete(existsTrain);
 }

 @Override
 public TrainDto findTrainById(long id) {
	return orikaBeanMapper.convertDTO(sportDao.findById(id).orElse(null), TrainDto.class);
 }

 @Override
 public List<TrainDto> findAllTrains() {
	List<Train> trains = sportDao.findAll();
	return orikaBeanMapper.convertListDTO(trains, TrainDto.class);
 }

 @Override
 public void addTrainForSport(long idTrain, long idSport) {
	Sport sport = sportDao.findById(idSport).orElse(null);
	Train train = sportDao.findById(idTrain).orElse(null);
	sport.addTrain(train);
 }

 @Override
 public List<TrainDto> findTrainsForSport(long idSport) {
	Sport sport = sportDao.findById(idSport).orElse(null);
	List<Train> trains = sport.getTrains();
	return orikaBeanMapper.convertListDTO(trains, TrainDto.class);
 }

 @Override
 public List<TrainDto> findTrainsForGym(long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	List<Train> trains = gym.getTrains();
	return orikaBeanMapper.convertListDTO(trains, TrainDto.class);
 }
}

Here, we are creating a manager class impl

WorktimeManangerServiceImpl.java In this class we'll implementaion WorktimeManangerService and @Override All methods

src/main/java/com/gym/managerImpl/WorktimeManangerServiceImpl.java):

package com.gym.managerImpl;

import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.gym.dao.GymDao;
import com.gym.dao.SportsManDao;
import com.gym.dao.WorktimeDao;
import com.gym.dto.SportsManDto;
import com.gym.dto.WorktimeDto;
import com.gym.manager.WorktimeManangerService;
import com.gym.model.Gym;
import com.gym.model.OrikaBeanMapper;
import com.gym.model.SportsMan;
import com.gym.model.Worktime;
import com.gym.service.WorktimeService;

@Transactional
@Service
public class WorktimeManangerServiceImpl implements WorktimeManangerService {

 @Autowired
 private OrikaBeanMapper orikaBeanMapper;
	
 @Autowired
 private WorktimeDao worktimeDao;
	
 @Autowired
 private WorktimeService worktimeService;
	
 @Autowired
 private GymDao gymDao;
	
 @Autowired
 private SportsManDao sportsManDao;

 @Override
 public void addSportsManForWork(long idSprtsMan, long idWorktime) {
	SportsMan sportsMan = sportsManDao.findById(idSprtsMan).orElse(null);
	Worktime worktime = worktimeDao.findById(idWorktime).orElse(null);
	worktime.addSportsManForWork(sportsMan);
 }

 @Override
 public WorktimeDto addWorktimeForGym(WorktimeDto worktimeDto, long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	Worktime worktime = orikaBeanMapper.map(worktimeDto, Worktime.class);
	return orikaBeanMapper.convertDTO(worktimeService.addWorktimeForGym(worktime, gym), WorktimeDto.class);
 }

 @Override
 public WorktimeDto editWorktime(WorktimeDto worktimeDto, Long id, long idGym) {
	Worktime worktime = orikaBeanMapper.map(worktimeDto, Worktime.class);
	Worktime existsWorktime = worktimeDao.findById(id).orElse(null);
	Gym gym = gymDao.findById(idGym).orElse(null);
	return orikaBeanMapper.convertDTO(worktimeService.editWorktime(worktime, existsWorktime, gym), WorktimeDto.class);
 }

 @Override
 public void deleteWorktime(Long id) {
	Worktime existsWorktime = worktimeDao.findById(id).orElse(null);
	worktimeDao.delete(existsWorktime);
 }

 @Override
 public WorktimeDto findWorktimeById(Long id) {
	return orikaBeanMapper.convertDTO(worktimeDao.findById(id).orElse(null), WorktimeDto.class);
 }

 @Override
 public List<WorktimeDto> findWorktimesForGym(Long idGym) {
	Gym gym = gymDao.findById(idGym).orElse(null);
	List<Worktime> worktimes = gym.getWorktimes();
	return orikaBeanMapper.convertListDTO(worktimes, WorktimeDto.class);
 }

 @Override
 public List<SportsManDto> findSportsManForWorktime(Long idWorktime) {
	Worktime worktime = worktimeDao.findById(idWorktime).orElse(null);
	List<SportsMan> sportsMans = worktime.getSportsMans();
	return orikaBeanMapper.convertListDTO(sportsMans, SportsManDto.class);
 }
}

@RestController API

@RestController is a convenience annotation for creating Restful controllers. It is a specialization of @Component and is autodetected through classpath scanning. It adds the @Controller and @ResponseBody annotations. It converts the response to JSON or XML. It does not work with the view technology, so the methods cannot return ModelAndView. It is typically used in combination with annotated handler methods based on the @RequestMapping annotation.

We will create eigth classes in controller package:

-> ArbitrateController.java
-> GymController.java
-> PaymentController.java
-> SportController.java
-> SportsManController.java
-> TrainController.java
-> UserController.java
-> WorktimeController.java

Here, we are creating a controller class

ArbitrateController.java We'll inject this bean into the ArbitrateManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/ArbitrateController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.ArbitrateDto;
import com.gym.manager.ArbitrateManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class ArbitrateController {

 @Autowired
 private ArbitrateManagerService arbitrateManagerService;
 
 @PostMapping("/addArbitrateForGym/{idGym}")
 ArbitrateDto addArbitrate(@RequestBody ArbitrateDto arbitrate, @PathVariable long idGym) {
	return arbitrateManagerService.addArbitrateForGym(arbitrate, idGym);
 }
 
 @PostMapping("/addArbitrateForSport/{idArbitrate}/{idSport}")
 void addArbitrateForSport(@PathVariable long idArbitrate, @PathVariable long idSport) {
	arbitrateManagerService.addArbitrateForSport(idArbitrate, idSport);
 }
 
 @PutMapping("/editArbitrate/{id}")
 ArbitrateDto editArbitrate(@RequestBody ArbitrateDto arbitrate, @PathVariable long id) {
	return arbitrateManagerService.editArbitrate(arbitrate, id);
 }
 
 @DeleteMapping("/deleteArbitrate/{id}")
 void deleteArbitrate(@PathVariable long id) {
	arbitrateManagerService.deleteArbitrate(id);
 }
 
 @GetMapping("/findAllArbitrates")
 List<ArbitrateDto> findAllArbitrates() {
	return arbitrateManagerService.findAllArbitrates();
 }
 
 @GetMapping("/findArbitrateById/{id}")
 ArbitrateDto findArbitrateById(@PathVariable long id) {
	return arbitrateManagerService.findArbitrateById(id);
 }
 
 @GetMapping("/findArbitratesForSport/{idSport}")
 List<ArbitrateDto> findArbitratesForSport(@PathVariable long idSport) {
	return arbitrateManagerService.findArbitratesForSport(idSport);
 }
 
 @GetMapping("/findArbitratesForGym/{idGym}")
 List<ArbitrateDto> findArbitratesForGym(@PathVariable long idGym) {
	return arbitrateManagerService.findArbitratesForGym(idGym);
 }
}

Here, we are creating a controller class

GymController.java We'll inject this bean into the GymManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/GymController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.GymDto;
import com.gym.manager.GymManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class GymController {
 
 @Autowired
 private GymManagerService gymManagerService;

 @PostMapping("/addGym")
 GymDto addGym(@RequestBody GymDto gym) {
	return gymManagerService.addGym(gym);
 }
 
 @PutMapping("/editGym/{id}")
 GymDto editGym(@RequestBody GymDto gym, @PathVariable Long id) {
	return gymManagerService.editGym(gym, id);
 }
 
 @DeleteMapping("/deleteGym/{id}")
 void deleteGym(@PathVariable Long id) {
	gymManagerService.deleteGym(id);
 }
 
 @GetMapping("/findGymById/{id}")
 GymDto findGymById(@PathVariable Long id) {
	return gymManagerService.findGymById(id);
 }
 
 @GetMapping("/findAllGyms")
 List<GymDto> findAllGyms() {
	return gymManagerService.findAllGyms();
 }
}

Here, we are creating a controller class

PaymentController.java We'll inject this bean into the PaymentManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/PaymentController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.PaymentDto;
import com.gym.manager.PaymentManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class PaymentController {
	
 @Autowired
 private PaymentManagerService paymentManagerService;
 
 @PostMapping("/addPayment/{idSportsMan}")
 PaymentDto addPayment(@RequestBody PaymentDto payment, @PathVariableLong idSportsMan) {
	return paymentManagerService.addPayment(payment, idSportsMan);
 }
	
 @PutMapping("/editPayment/{id}")
 PaymentDto editPayment(@RequestBody PaymentDto payment, @PathVariable Long id) {
	return paymentManagerService.editPayment(payment, id);
 }
	
 @DeleteMapping("/deletePayment/{id}")
 void deletePayment(@PathVariable Long id) {
	paymentManagerService.deletePayment(id);
 }
	
 @GetMapping("/findPaymentById/{id}")
 PaymentDto findPaymentById(@PathVariable Long id) {
	return paymentManagerService.findPaymentById(id);
 }
	
 @GetMapping("/findPaymentForSportsMan/{idSportsMan}")
 List<PaymentDto> findPaymentsForSportsMan(@PathVariable Long idSportsMan) {
	return paymentManagerService.findPaymentsForSportsMan(idSportsMan);
 }
}

Here, we are creating a controller class

SportController.java We'll inject this bean into the SportManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/SportController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.SportDto;
import com.gym.manager.SportManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class SportController {
 
 @Autowired
 private SportManagerService sportManagerService;

 @PostMapping("/addSportForGym/{idGym}")
 SportDto addSportForGym(@RequestBody SportDto sport, @PathVariable Long idGym) {
	return sportManagerService.addSportForGym(sport, idGym);
 }
	
 @PostMapping("/addSportForSportsMan/{idSport}/{idSportsMan}")
 void addSportForSportsMan(@PathVariable long idSport, @PathVariable long idSportsMan) {
	sportManagerService.addSportForSportsMan(idSport, idSportsMan);
 }
	
 @PutMapping("/editSport/{id}")
 SportDto editSport(@RequestBody SportDto sport, @PathVariable Long id) {
	return sportManagerService.editSport(sport, id);
 }
	
 @DeleteMapping("/deleteSport/{id}")
 void deleteSport(@PathVariable Long id) {
	sportManagerService.deleteSport(id);
 }
	
 @GetMapping("/findSportById/{id}")
 SportDto findSportById(@PathVariable Long id) {
	return sportManagerService.findSportById(id);
 }
	
 @GetMapping("/findSportsForSportsMan/{idSportsMan}")
 List<SportDto> findSportsForSportsMan(@PathVariable Long idSportsMan) {
	return sportManagerService.findSportsForSportsMan(idSportsMan);
 }
	
 @GetMapping("/findSportsForGym/{idGym}")
 List<SportDto> findSportsForGym(@PathVariable Long idGym) {
	return sportManagerService.findSportsForGym(idGym);
  }
}

Here, we are creating a controller class

SportsManController.java We'll inject this bean into the SportsManManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/SportsManController.java):

package com.gym.controller;

import  java.util.List;
import  org.springframework.beans.factory.annotation.Autowired;
import  org.springframework.web.bind.annotation.CrossOrigin;
import  org.springframework.web.bind.annotation.DeleteMapping;
import  org.springframework.web.bind.annotation.GetMapping;
import  org.springframework.web.bind.annotation.PathVariable;
import  org.springframework.web.bind.annotation.PostMapping;
import  org.springframework.web.bind.annotation.PutMapping;
import  org.springframework.web.bind.annotation.RequestBody;
import  org.springframework.web.bind.annotation.RequestMapping;
import  org.springframework.web.bind.annotation.RestController;
import  com.gym.dto.SportsManDto;
import  com.gym.manager.SportsManManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class SportsManController {

 @Autowired
 private SportsManManagerService sportsManManagerService;

 @PostMapping("/addSportsMan/{id}")
 SportsManDto addSportsMan(@RequestBody SportsManDto sportsMan) {
	return sportsManManagerService.addSportsMan(sportsMan);
 }
 
 @PutMapping("/editSportsMan/{id}")
 SportsManDto editSportsMan(@RequestBody SportsManDto sportsMan, @PathVariable Long id) {
	return sportsManManagerService.editSportsMan(sportsMan, id);
 }
 
 @DeleteMapping("/deleteSportsMan/{id}")
 void deleteSportsMan(@PathVariable Long id) {
	sportsManManagerService.deleteSportsMan(id);
 }
 
 @GetMapping("/findSportsManById/{id}")
 SportsManDto findSportsManById(@PathVariable Long id) {
	return sportsManManagerService.findSportsManById(id);
 }
 
 @GetMapping("/findAllSportsMans")
 List<SportsManDto> findAllSportsMans() {
	return sportsManManagerService.findAllSportsMans();
 }
}

Here, we are creating a controller class

UserController.java We'll inject this bean into the ArbitrateManagerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/UserController.java):

package com.gym.controller;

import java.util.Optional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.model.User;
import com.gym.service.UserService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class UserController {

 @Autowired
 private UserService userService;
	
 @PostMapping("/addUser")
  User addUser(@RequestBody User user) {
	 return userService.addUser(user);
  }
	 
 @PutMapping("/editUser/{id}")
 User editUser(@RequestBody User user, @PathVariable long id) {
	 return userService.editUser(user, id);
 }
	 
 @GetMapping("/findUserById")
 User findUserById(@PathVariable long id) {
	return userService.findUserById(id);
 }
	  
 @GetMapping("/findUserByUsername/{username}")
 Optional<User> findUserByUsername(@PathVariable String username) {
	return userService.findUserByUsername(username);
 }
	  
 @DeleteMapping("/deleteUser/{id}")
 void deleteUser(@PathVariable long id) {
	userService.deleteUser(id);
  }  
}

Here, we are creating a controller class

WorktimeController.java We'll inject this bean into the WorktimeManangerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/WorktimeController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.SportsManDto;
import com.gym.dto.WorktimeDto;
import com.gym.manager.WorktimeManangerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class WorktimeController {

 @Autowired
 private WorktimeManangerService worktimeManangerService;

 @PostMapping("/addSportsManForWork/{idSprtsMan}/{idWorktime}")
 void addSportsManForWork(@PathVariable long idSprtsMan,  @PathVariable long idWorktime) {
	worktimeManangerService.addSportsManForWork(idSprtsMan, idWorktime);
  }
	
 @PostMapping("/addWorktimeForGym/{idGym}")
 WorktimeDto addWorktimeForGym(@RequestBody WorktimeDto worktime, @PathVariable long idGym) {
	return worktimeManangerService.addWorktimeForGym(worktime, idGym);
 }
 
 @PutMapping("/editWorktime/{id}/{idGym}")
 WorktimeDto editWorktime(@RequestBody WorktimeDto worktime, @PathVariable Long id, @PathVariable long idGym) {
	return worktimeManangerService.editWorktime(worktime, id, idGym);
 }
 
 @DeleteMapping("/deleteWorktime/{id}")
 void deleteWorktime(@PathVariable Long id) {
	worktimeManangerService.deleteWorktime(id);
 }
 
 @GetMapping("/findWorktimeById/{id}")
 WorktimeDto findWorktimeById(@PathVariable Long id) {
    return worktimeManangerService.findWorktimeById(id);
 }
 
 @GetMapping("/findWorktimesForGym/{idGym}")
List<WorktimeDto> findWorktimesForGym(@PathVariable Long idGym) {
	return worktimeManangerService.findWorktimesForGym(idGym);
 }
	  
 @GetMapping("/findSportsManForWorktime/{idWorktime}")
 List<SportsManDto> findSportsManForWorktime(@PathVariable Long idWorktime) {
	return worktimeManangerService.findSportsManForWorktime(idWorktime);
  }
}

Here, we are creating an Entity

TrainController.java We'll inject this bean into the WorktimeManangerService bean using @Autowired on the field definition: We need to add map requests with request mapping annotations e.g. @RequestMapping, @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

src/main/java/com/gym/controller/TrainController.java):

package com.gym.controller;

import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.CrossOrigin;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.gym.dto.TrainDto;
import com.gym.manager.TrainManagerService;

@RestController
@RequestMapping("api")
@CrossOrigin(origins = "*")
public class TrainController {

 @Autowired
 private TrainManagerService trainManagerService;

 @PostMapping("/addTrainForGym/{idGym}")
 TrainDto addTrainForGym(@RequestBody TrainDto train, @PathVariable long idGym) {
   return trainManagerService.addTrainForGym(train, idGym);
 }

 @PostMapping("/addTrainForSport/{idTrain}/{idSport}")
 void addTrainForSport(@PathVariable long idTrain, @PathVariable long idSport) {
   trainManagerService.addTrainForSport(idTrain, idSport);
 }

 @PutMapping("/editTrain/{id}")
 TrainDto editTrain(@RequestBody TrainDto train, @PathVariable long id) {
   return trainManagerService.editTrain(train, id);
 }

 @DeleteMapping("/deleteTrain/{id}")
 void deleteTrain(@PathVariable long id) {
   trainManagerService.deleteTrain(id);
 }

 @GetMapping("/findTrainById/{id}")
 TrainDto findTrainById(@PathVariable long id) {
   return trainManagerService.findTrainById(id);
 }

 @GetMapping("/findAllTrains")
 List<TrainDto> findAllTrains() {
   return trainManagerService.findAllTrains();
 }
 
 @GetMapping("/findTrainsForSport/{idSport}")
 List<TrainDto> findTrainsForSport(@PathVariable long idSport) {
   return trainManagerService.findTrainsForSport(idSport);
 }
	
 @GetMapping("/findTrainsForGym/{idGym}")
 List<TrainDto> findTrainsForGym(@PathVariable long idGym) {
   return trainManagerService.findTrainsForGym(idGym);
 }
}

GymApplication

@SpringBootApplication and its use in a simple Spring Boot application. We use the @SpringBootApplication annotation in our Application or Main class to enable a host of features, e.g. Java-based Spring configuration, component scanning, and in particular for enabling Spring

src/main/java/com/gym/GymApplication.java):

package com.gym;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@ComponentScan
@SpringBootApplication
public class GymApplication {

 public static void main(String[] args) {
   SpringApplication.run(GymApplication.class, args);
		
   System.out.println("App started....");
	}
}

Conclusion

Now we have an overview of Spring Boot CRUD example when building an App with clean architect. we have also added Service Components.

We also take a look at client-server architecture for REST API using Spring Web MVC & Spring Data JPA, as well, we are gooing to continue with Angular 10 project structure for building a front-end app to make HTTP requests and consume responses.

---

Gyms organization application with spring boot and angular part 1

Download Gyms Organization Application From Github