Building gestion school with Spring boot & Angular Pt 2

Getting Started | Building an Application with Spring Boot

---

Build an application enterprise with Spring boot and Angular use Jpa

In this part we will continue with Repositories and Services

When using Spring Data JPA to implement the persistence layer, the repository typically returns one or more instances of the root class. However, more often than not, we don't need all the properties of the returned objects.

In such cases, it may be desirable to retrieve data as objects of customized types. These types reflect partial views of the root class, containing only properties we care about. This is where projections come in handy.

We need to create these interface dao

-> ActivityDao.java

-> CoefficientDao.java

-> CourseDao.java

-> ExamDao.java

-> LevelDao.java

-> ManagerDao.java

-> NoteDao.java

-> ProgramDao.java

-> RoomDao.java

-> SchoolDao.java

-> SchoolingDao.java

-> SubjectDao.java

Here, we are creating an interface ActivityDao

src/main/java/com/school/dao/ActivityDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Activity;

@Repository
public interface ActivityDao extends JpaRepository<Activity, Long>{

}

Here, we are creating an interface CoefficientDao

src/main/java/com/school/dao/CoefficientDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Coefficient;

@Repository
public interface CoefficientDao extends JpaRepository<Coefficient, Long>{

}

Here, we are creating an interface CourseDao

src/main/java/com/school/dao/CourseDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Course;

@Repository
public interface CourseDao extends JpaRepository<Course, Long>{

}

Here, we are creating an interface ExamDao

src/main/java/com/school/dao/ExamDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Exam;

@Repository
public interface ExamDao extends JpaRepository<Exam, Long>{

}

Here, we are creating an interface LevelDao

src/main/java/com/school/dao/LevelDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Level;

@Repository
public interface LevelDao extends JpaRepository<Level, Long>{

}

Here, we are creating an interface ManagerDao

src/main/java/com/school/dao/ManagerDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Manager;

@Repository
public interface ManagerDao extends JpaRepository<Manager, Long>{

}

Here, we are creating an interface NoteDao

src/main/java/com/school/dao/NoteDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Note;

@Repository
public interface NoteDao extends JpaRepository<Note, Long>{

}

Here, we are creating an interface ProgramDao

src/main/java/com/school/dao/ProgramDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Program;

@Repository
public interface ProgramDao extends JpaRepository<Program, Long>{

}

Here, we are creating an interface RoomDao

src/main/java/com/school/dao/RoomDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;
import com.school.modal.Room;

@Repository
public interface RoomDao extends JpaRepository<Room, Long>{

}

Here, we are creating an interface SchoolDao

src/main/java/com/school/dao/SchoolDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.School;
import com.school.modal.Room;

@Repository
public interface SchoolDao extends JpaRepository<School, Long>{

}

Here, we are creating an interface SchoolingDao

src/main/java/com/school/dao/SchoolingDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.School;
import com.school.modal.Schooling;

@Repository
public interface SchoolingDao extends JpaRepository<Schooling, Long>{

}

Here, we are creating an interface SubjectDao

src/main/java/com/school/dao/SubjectDao.java):

package com.school.dao;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.School;
import com.school.modal.Subject;

@Repository
public interface SubjectDao extends JpaRepository<Subject, Long>{

}

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 these interfaces in service package:

-> ActivityService.java

-> CoefficientService.java

-> CourseService.java

-> ExamService.java

-> LevelService.java

-> ManagerService.java

-> NoteService.java

-> ProgramService.java

-> RoomService.java

-> SchoolService.java

-> SchoolingService.java

-> SubjectService.java

Here, we are creating an interface ActivityService

src/main/java/com/school/service/ActivityService.java):

package com.school.service;
import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.Activity;

@Service
public interface ActivityService {
	
  Activity addActivity(Activity activity, long id);
	
  Activity editActivity(Activity activity, long id);
	
  Activity findActivity(long id);
	
  void deleteActivity(long id);
	
  List<Activity> findActivitiesForSchool(long id);

}
 

Here, we are creating an interface CoefficientService

src/main/java/com/school/service/CoefficientService.java):

package com.school.service;

import org.springframework.stereotype.Service;
import com.school.modal.Coefficient;

@Service
public interface CoefficientService {
	
 Coefficient addCoefficient(Coefficient coefficient, long id);
	
 Coefficient editCoefficient(Coefficient coefficient, long id);
	
 Coefficient findCoefficient(long id);
	
 void deleteCoefficient(long id);

}

Here, we are creating an interface CourseService

src/main/java/com/school/service/CourseService.java):

package com.school.service;

import org.springframework.stereotype.Service;
import com.school.modal.Course;

@Service
public interface CourseService {

 Course addCourse(Course course, long idLevel, long idSubject);
	
 Course editCourse(Course course, long idCourse, long idSubject);
	
 Course findCourse(long id);
	
 void deleteCourse(long idCourse, long idSubject);
}

Here, we are creating an interface ExamService

src/main/java/com/school/service/ExamService.java):

package com.school.service;

import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.Exam;

@Service
public interface ExamService {

 Exam addExam(Exam exam, long idSchool, long  idSubject);
	
 Exam editExam(Exam exam, long id);
	
 Exam findExam(long id);
	
 void deleteExam(long id, long idSubject);
	
 List<Exam> findExamsForSchool(long id);

}
 

Here, we are creating an interface LevelService

src/main/java/com/school/service/LevelService.java):

package com.school.service;

import java.util.List;
import com.school.modal.Level;

public interface LevelService {
	
 Level addLevel(Level level, long id);
	
 Level editLevel(Level level, long id);
	
 Level findLevel(long id);
	
 Level findLevelForRoom(long id);
	
 void deleteLevel(long id);
	
 void addLevelToRoom(long idRoom, long idLevel);
	
 List<Level> findLevels();
	
 void deleteLevelFromRoom(long idRoom, long idLevel);
	
}
 

Here, we are creating an interface ManagerService

src/main/java/com/school/service/ManagerService.java):

package com.school.service;

import org.springframework.stereotype.Service;
import com.school.modal.Manager;

@Service
public interface ManagerService {

 Manager addManager(Manager manager, long id);
	
 Manager editManager(Manager manager, long id);
	
 Manager findManager(long id);
	
 Manager findManagerForSchool(long id);
	
 void deleteManager(long id, long idSchhol);
 
}
 

Here, we are creating an interface NoteService

src/main/java/com/school/service/NoteService.java):

package com.school.service;

import org.springframework.stereotype.Service;
import com.school.modal.Note;

@Service
public interface NoteService {
	
 Note addNote(Note note, long id);
	
 Note editNote(Note note, long id);
	
 Note findNote(long id);
	
 void deleteNote(long id);

}

Here, we are creating an interface ProgramService

src/main/java/com/school/service/ProgramService.java):

package com.school.service;

import org.springframework.stereotype.Service;
import com.school.modal.Program;

@Service
public interface ProgramService {

 Program addProgram(Program program, long id);
	
 Program editProgram(Program program, long id);
	
 Program findProgram(long id);
 
 void deleteProgram(long id);
	
}
 

Here, we are creating an interface RoomService

src/main/java/com/school/service/RoomService.java):

package com.school.service;

import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.Room;

@Service
public interface RoomService {
	
 Room addRoom(Room room, long id);
	
 Room editRoom(Room room, long id);
	
 Room findRoom(long id);
	
 void deleteRoom(long id);
	
 List<Room> findRoomsForSchool(long id);

}
 

Here, we are creating an interface SchoolService

src/main/java/com/school/service/SchoolService.java):

 
package com.school.service;

import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.School;

@Service
public interface SchoolService {
	
 School addSchool(School school);
	
 School editSchool(School school, long id);
	
 School findSchool(long id);
	
 void deleteSchool(long id);
	
 List<School> findSchools();

}
 

Here, we are creating an interface SchoolingService

src/main/java/com/school/service/SchoolingService.java):

package com.school.service;

import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.Schooling;

@Service
public interface SchoolingService {
	
 Schooling addSchooling(Schooling schooling, long id);
	
 Schooling editSchooling(Schooling schooling, long id);
	
 Schooling findSchooling(long id);
	
 void deleteSchooling(long id);
	
 List<Schooling> findSchoolingsForSchool(long id);

}

Here, we are creating an interface SubjectService

src/main/java/com/school/service/SubjectService.java):

package com.school.service;

import java.util.List;
import org.springframework.stereotype.Service;
import com.school.modal.Subject;

@Service
public interface SubjectService {

 Subject addSubject(Subject subject, long idSchool);
	
 Subject editSubject(Subject subject, long id);
	
 Subject findSubject(long id);
	
 Subject findSubjectForExam(long id);
	
 Subject findSubjectForCourse(long id);
	
 void deleteSubject(long id);
	
 List<Subject> findAllSubjectsForSchool(long id);
	
 List<Subject> findSubjectsForSchool(long id);
	
}

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 these class in the impl package

-> ActivityServiceImpl.java

-> CoefficientServiceImpl.java

-> CourseServiceImpl.java

-> ExamServiceImpl.java

-> LevelServiceImpl.java

-> ManagerServiceImpl.java

-> NoteServiceImpl.java

-> ProgramServiceImpl.java

-> RoomServiceImpl.java

-> SchoolServiceImpl.java

-> SchoolingServiceImpl.java

-> SubjectServiceImpl.java

Here, we are creating a class ActivityServiceImpl

src/main/java/com/school/impl/ActivityServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.school.dao.ActivityDao;
import com.school.dao.SchoolDao;
import com.school.modal.Activity;
import com.school.modal.School;
import com.school.service.ActivityService;

 @Component
@Transactional 
public class ActivityServiceImpl implements ActivityService {
	
   @Autowired
   private ActivityDao activityDao;
	
	@Autowired
    private SchoolDao schoolDao;

 @Override
 public Activity addActivity(Activity activity,  long id) {
		School school = schoolDao.findById(id).get();
		school.addActivity(activity);
		activity.setCreatedAt(new Date());
		return activityDao.save(activity);
	}

 @Override
 public Activity editActivity(Activity activity,  long id) {
		Activity existActivity = activityDao.findById(id).get();
		existActivity.setType(activity.getType());
		existActivity.setDay(activity.getDay());
		existActivity.setStartDate(activity.getStartDate());
		existActivity.setEndDate(activity.getEndDate());
		existActivity.setDescription(activity.getDescription());
		existActivity.setDate(activity.getDate());
		return activityDao.save(existActivity);
	}

 @Override
 public Activity findActivity( long id) {
		return activityDao.findById(id).get();
	}

 @Override
 public void deleteActivity( long id) {
		 activityDao.deleteById(id);
	}

 @Override
 public List<Activity> findActivitiesForSchool( long id) {
		School school = activityDao.findById(id).get();
		return school.getActivities();
	}

}

Here, we are creating a class CoefficientServiceImpl

src/main/java/com/school/impl/CoefficientServiceImpl.java):

package com.school.impl;

import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.CoefficientDao;
import com.school.dao.ProgramDao;
import com.school.modal.Coefficient;
import com.school.modal.Program;
import com.school.service.CoefficientService;

 @Component
@Transactional 
public class CoefficientServiceImpl implements CoefficientService {
	
 @Autowired
 private CoefficientDao coefficientDao;
	
 @Autowired
 private ProgramDao programDao;

 @Override
 public Coefficient addCoefficient(Coefficient coefficient, long id) {
		Program program = programDao.findById(id).get();
		coefficient.setCreatedAt(new Date());
	     program.addCoefficient(coefficient);
		return coefficientDao.save(coefficient);
	}

 @Override
 public Coefficient editCoefficient(Coefficient coefficient, long id) {
		Coefficient existCoefficient = coefficientDao.findById(id).get();
		existCoefficient.setGrade(coefficient.getGrade());
		existCoefficient.setDescription(coefficient.getDescription());
		return coefficientDao.save(existCoefficient);
	}

 @Override
 public Coefficient findCoefficient(long id) {
		return coefficientDao.findById(id).get();
	}

 @Override
 public void deleteCoefficient(long id) {
		coefficientDao.deleteById(id);		
	}
		
}

Here, we are creating a class CourseServiceImpl

src/main/java/com/school/impl/CourseServiceImpl.java):

package com.school.impl;

import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.CourseDao;
import com.school.dao.LevelDao;
import com.school.dao.SubjectDao;
import com.school.modal.Course;
import com.school.modal.Level;
import com.school.modal.Subject;
import com.school.service.CourseService;

 @Component
@Transactional 
public class CourseServiceImpl implements CourseService {
	
 @Autowired
 private CourseDao courseDao;
	
 @Autowired
 private LevelDao levelDao;
	
 @Autowired
 private SubjectDao subjectDao;

 @Override
 public Course addCourse(Course course, long idLevel, long idSubject) {
		Level level = levelDao.findById(idLevel).get();
		Subject subject = subjectDao.findById(idSubject).get();
		course.setCreatedAt(new Date());
		level.addCourse(course);
		course.setSubject(subject);
		subject.setCourse(course);
		return courseDao.save(course);
	}

 @Override
 public Course editCourse(Course course, long idCourse, long idSubject) {
		Subject subject = subjectDao.findById(idSubject).get();
		Course existsCourse = courseDao.findById(idCourse).get();
		existsCourse.setDate(course.getDate());
		existsCourse.setStartDate(course.getStartDate());
		existsCourse.setEndDate(course.getEndDate());
		existsCourse.setDescription(course.getDescription());
		subject.setCourse(existsCourse);
		existsCourse.setSubject(subject);
		return courseDao.save(existsCourse);
	}

 @Override
 public Course findCourse(long id) {
		return courseDao.findById(id).get();
	}

 @Override
 public void deleteCourse(long idCourse, long idSubject) {
		Subject subject = subjectDao.findById(idSubject).get();
		Course existsCourse = courseDao.findById(idCourse).get();
		subject.setCourse(null);
		existsCourse.setSubject(null);
		courseDao.delete(existsCourse);	
	}
	
}

Here, we are creating a class ExamServiceImpl

src/main/java/com/school/impl/ExamServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.ExamDao;
import com.school.dao.SubjectDao;
import com.school.dao.SchoolDao;
import com.school.modal.Exam;
import com.school.modal.Subject;
import com.school.modal.School;
import com.school.service.ExamService;

@Component
@Transactional 
public class ExamServiceImpl implements ExamService {

 @Autowired
 private ExamDao examDao;
	
 @Autowired
 private SchoolDao schoolDao;
	
 @Autowired
 private SubjectDao subjectDao;

 @Override
 public Exam addExam(Exam exam, long idSchool, long idSubject) {
		School school = schoolDao.findById(idSchool).get();
		Subject subject = subjectDao.findById(idSubject).get();
		exam.setCreatedAt(new Date());
		school.addExam(exam);
		exam.setSubject(subject);
		subject.setExam(exam);
		return examDao.save(exam);
	}

 @Override
 public Exam editExam(Exam exam, long id) {
		Exam existExam = examDao.findById(id).get();
		existExam.setDate(exam.getDate());
		existExam.setDescription(exam.getDescription());
		existExam.setStart(exam.getStart());
		existExam.setEnd(exam.getEnd());
		return examDao.save(existExam);
	}

 @Override
 public Exam findExam(long id) {
		return examDao.findById(id).get();
	}

 @Override
 public void deleteExam(long id, long idSubject) {
		Exam existExam = examDao.findById(id).get();
		Subject subject = subjectDao.findById(idSubject).get();
		existExam.setSubject(null);
		subject.setExam(null);
		examDao.delete(existExam);
	}

 @Override
 public List<Exam> findExamsForSchool(long id) {
		School school = schoolDao.findById(id).get();
		return school.getExams();
	}

}
 

Here, we are creating a class LevelServiceImpl

src/main/java/com/school/impl/LevelServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.LevelDao;
import com.school.dao.RoomDao;
import com.school.dao.SchoolingDao;
import com.school.modal.Level;
import com.school.modal.Room;
import com.school.modal.Schooling;
import com.school.service.LevelService;

 @Component
@Transactional 
public class LevelServiceImpl implements LevelService {
	
 @Autowired
 private LevelDao levelDao;
	
 @Autowired
 private SchoolingDao schoolingDao;
	
 @Autowired
 private RoomDao roomDao;

 @Override
 public Level addLevel(Level level, longid) {
		Schooling schooling = schoolingDao.findById(id).get();
		level.setCreatedAt(new Date());
		schooling.addLevel(level);
		return levelDao.save(level);
	}

 @Override
 public Level editLevel(Level level, longid) {
		Level existLevel = levelDao.findById(id).get();
		existLevel.setLabel(level.getLabel());
		existLevel.setDescription(level.getDescription());
		return levelDao.save(existLevel);
	}

 @Override
 public Level findLevel(longid) {
		return levelDao.findById(id).get();
	}

 @Override
 public void deleteLevel(longid) {
		levelDao.deleteById(id);	
	}

 @Override
 public void addLevelToRoom(longidRoom, longidLevel) {
		Level existLevel = levelDao.findById(idLevel).get();
		Room room = roomDao.findById(idRoom).get();
		existLevel.setRoom(room);
		room.setLevel(existLevel);
	}


 @Override
 public List<Level> findLevels() {
		return levelDao.findAll();
	}

 @Override
 public void deleteLevelFromRoom(longidRoom, longidLevel) {
		Level existLevel = levelDao.findById(idLevel).get();
		Room room = roomDao.findById(idRoom).get();
		existLevel.setRoom(null);
		room.setLevel(null);
	}

 @Override
 public Level findLevelForRoom(longidRoom) {
		Room room = roomDao.findById(idRoom).get();
		return room.getLevel();
	}
}
 

Here, we are creating a class ManagerServiceImpl

src/main/java/com/school/impl/ManagerServiceImpl.java):

package com.school.impl;

import javax.transaction.Transactional;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import com.school.dao.ManagerDao;
import com.school.dao.SchoolDao;
import com.school.modal.Manager;
import com.school.modal.School;
import com.school.service.ManagerService;

 @Component
@Transactional 
public class ManagerServiceImpl implements ManagerService {
	
 @Autowired
 private ManagerDao managerDao;
	
 @Autowired
 private SchoolDao schoolDao;

 @Override
 public Manager addManager(Manager manager, longid) {
		School school = schoolDao.findById(id).get();
		manager.setSchool(school);
		school.setManager(manager);
		return managerDao.save(manager);
	}

 @Override
 public Manager editManager(Manager manager, longid) {
		Manager existManager = managerDao.findById(id).get();
		existManager.setFirstName(manager.getFirstName());
		existManager.setLastName(manager.getLastName());
		return managerDao.save(existManager);
	}

 @Override
 public Manager findManager(longid) {
		return managerDao.findById(id).get();
	}

 @Override
 public void deleteManager(longid, longidSchool) {
	   School school = schoolDao.findById(idSchhol).get();
	   school.setManager(null);
       managerDao.deleteById(id);	
	}

 @Override
 public Manager findManagerForSchool(longid) {
		School school = schoolDao.findById(id).get();
		return school.getManager();
	}

}
 

Here, we are creating a class NoteServiceImpl

src/main/java/com/school/impl/NoteServiceImpl.java):

package com.school.impl;

import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.ExamDao;
import com.school.dao.NoteDao;
import com.school.modal.Exam;
import com.school.modal.Note;
import com.school.service.NoteService;

 @Component
@Transactional 
public class NoteServiceImpl implements NoteService {
	
 @Autowired
 private NoteDao noteDao;
	
 @Autowired
 private ExamDao examDao;

 @Override
 public Note addNote(Note note, longid) {
		Exam exam = examDao.findById(id).get();
		note.setCreatedAt(new Date());
		exam.addNote(note);
		return noteDao.save(note);
	}

 @Override
 public Note editNote(Note note, longid) {
		Note existNote = noteDao.findById(id).get();
		existNote.setScore(note.getScore());
		existNote.setDescription(note.getDescription());
		return noteDao.save(existNote);
	}

 @Override
 public Note findNote(longid) {
		return noteDao.findById(id).get();
	}

 @Override
 public void deleteNote(longid) {
		noteDao.deleteById(id);
	}	

}

Here, we are creating a class ProgramServiceImpl

src/main/java/com/school/impl/ProgramServiceImpl.java):

package com.school.impl;

import java.util.Date;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.SubjectDao;
import com.school.dao.ProgramDao;
import com.school.modal.Subject;
import com.school.modal.Program;
import com.school.service.ProgramService;

 @Component
@Transactional 
public class ProgramServiceImpl implements ProgramService {
	
 @Autowired
 private ProgramDao programDao;
	
 @Autowired
 private SubjectDao matterDao;

 @Override
 public Program addProgram(Program program, longid) {
		Subject matter = matterDao.findById(id).get();
		program.setCreatedAt(new Date());
		matter.addProgram(program);
		return programDao.save(program);
	}

 @Override
 public Program editProgram(Program program, longid) {
	   Program existProgram = programDao.findById(id).get();
	   existProgram.setName(program.getName());
	   existProgram.setDescription(program.getDescription());
		return programDao.save(existProgram);
	}

 @Override
 public Program findProgram(longid) {
		return programDao.findById(id).get();
	}

 @Override
 public void deleteProgram(longid) {
        programDao.deleteById(id);
	}
}
 

Here, we are creating a class RoomServiceImpl

src/main/java/com/school/impl/RoomServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.LevelDao;
import com.school.dao.RoomDao;
import com.school.dao.SchoolDao;
import com.school.modal.Level;
import com.school.modal.Room;
import com.school.modal.School;
import com.school.service.RoomService;

 @Component
@Transactional 
public class RoomServiceImpl implements RoomService {
	
 @Autowired
 private RoomDao roomDao;

 @Autowired
 private SchoolDao schoolDao;
	
 @Override
 public Room addRoom(Room room, longid) {
		School school = schoolDao.findById(id).get();
		room.setCreatedAt(new Date());
		school.addRoom(room);
		return roomDao.save(room);
	}

 @Override
 public Room editRoom(Room room, longid) {
		Room existRoom = roomDao.findById(id).get();
		existRoom.setCode(room.getCode());
		existRoom.setCapacity(room.getCapacity());
		existRoom.setDescription(room.getDescription());
		return roomDao.save(existRoom);
	}

 @Override
 public Room findRoom(longid) {
		return roomDao.findById(id).get();
	}

 @Override
 public void deleteRoom(longid) {
		roomDao.deleteById(id);
	}

 @Override
 public List<Room> findRoomsForSchool(longid) {
		School school = schoolDao.findById(id).get();
		return school.getRooms();
	}

}
 

Here, we are creating a class SchoolServiceImpl

src/main/java/com/school/impl/SchoolServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.SchoolDao;
import com.school.modal.School;
import com.school.service.SchoolService;

@Component
@Transactional 
public class SchoolServiceImpl implements SchoolService {
	
 @Autowired
 private SchoolDao schoolDao;

 @Override
 public School addSchool(School school) {
		school.setCreatedAt(new Date());
		return schoolDao.save(school);
	}

 @Override
 public School editSchool(School school, longid) {
		School existSchool = schoolDao.findById(id).get();
		existSchool.setName(school.getName());
		existSchool.setCity(school.getCity());
		existSchool.setDescription(school.getDescription());
		existSchool.setOpen(school.getOpen());
		existSchool.setClose(school.getClose());
		return schoolDao.save(existSchool);
	}

 @Override
 public School findSchool(longid) {
		return schoolDao.findById(id).get();
	}

 @Override
 public void deleteSchool(longid) {
		schoolDao.deleteById(id);
	}

 @Override
 public List<School> findSchools() {
		return schoolDao.findAll();
	}

}

Here, we are creating a class SchoolingServiceImpl

src/main/java/com/school/impl/SchoolingServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.SchoolDao;
import com.school.dao.SchoolingDao;
import com.school.modal.School;
import com.school.modal.Schooling;
import com.school.service.SchoolingService;

 @Component
@Transactional 
public class SchoolingServiceImpl implements SchoolingService {
	
 @Autowired
 private SchoolingDao schoolingDao;
	
 @Autowired
 private SchoolDao schoolDao;

 @Override
 public Schooling addSchooling(Schooling schooling, longid) {
		School school = schoolDao.findById(id).get();
		school.addSchooling(schooling);
		schooling.setCreatedAt(new Date());
		return schoolingDao.save(schooling);
	}

 @Override
 public Schooling editSchooling(Schooling schooling, longid) {
		Schooling existSchooling = schoolingDao.findById(id).get();
		existSchooling.setYear(schooling.getYear());
		existSchooling.setDescription(schooling.getDescription());
		return schoolingDao.save(existSchooling);
	}

 @Override
 public Schooling findSchooling(longid) {
		return schoolingDao.findById(id).get();
	}

 @Override
 public void deleteSchooling(longid) {
		schoolingDao.deleteById(id);		
	}

 @Override
 public List<Schooling> findSchoolingsForSchool(longid) {
		School school = schoolDao.findById(id).get();
		return school.getSchoolings();
	}

}
 

Here, we are creating a class SubjectServiceImpl

src/main/java/com/school/impl/SubjectServiceImpl.java):

package com.school.impl;

import java.util.Date;
import java.util.List;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.school.dao.SubjectDao;
import com.school.dao.CourseDao;
import com.school.dao.ExamDao;
import com.school.dao.SchoolDao;
import com.school.modal.Subject;
import com.school.modal.Course;
import com.school.modal.Exam;
import com.school.modal.School;
import com.school.service.SubjectService;

@Component
@Transactional 
public class SubjectServiceImpl implements SubjectService {
	
 @Autowired
 private SubjectDao subjectDao;
	
 @Autowired
 private SchoolDao schoolDao;
	
 @Autowired
 private ExamDao examDao;
	
 @Autowired
 private CourseDao courseDao;

 @Override
 public Subject addSubject(Subject subject, longidSchool) {
		School school = schoolDao.findById(idSchool).get();
		subject.setCreatedAt(new Date());
		school.addSubject(subject);
		return subjectDao.save(subject);
	}

 @Override
 public Subject editSubject(Subject subject, longid) {
		Subject existSubject = subjectDao.findById(id).get();
		existSubject.setName(subject.getName());
		existSubject.setColor(subject.getColor());
		existSubject.setDescription(subject.getDescription());
		return subjectDao.save(existSubject);
	}

 @Override
 public Subject findSubject(longid) {
		return subjectDao.findById(id).get();
	}

 @Override
 public void deleteSubject(longid) {
		subjectDao.deleteById(id);
	}

 @Override
 public List<Subject> findAllSubjectsForSchool(longid) {
		School school = schoolDao.findById(id).get();
		return school.getSubjects();
	}

 @Override
 public Subject findSubjectForExam(longid) {
		Exam exam = examDao.findById(id).get();
		return exam.getSubject();
	}

 @Override
 public Subject findSubjectForCourse(longid) {
		Course course = courseDao.findById(id).get();
		return course.getSubject();
	}

 @Override
 public List<Subject> findSubjectsForSchool(longid) {
		School school = schoolDao.findById(id).get();
		return school.getSubjects();
	}
}

@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 these class in controller package:

-> ActivityController.java

-> CoefficientController.java

-> CourseController.java

-> ExamController.java

-> LevelController.java

-> ManagerConntroller.java

-> NoteController.java

-> ProgramController.java

-> RoomController.java

-> SchoolController.java

-> SchoolingController.java

-> SubjectController.java

Here, we are creating a class ActivityController

src/main/java/com/school/controller/ActivityController.java):

package com.school.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.school.modal.Activity;
import com.school.service.ActivityService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class ActivityController {

 @Autowired
 private ActivityService activityService;

	@PostMapping("/addActivity/{id}")
	Activity addActivity(@RequestBody Activity activity, @PathVariable  long id) {
		return activityService.addActivity(activity, id);
	}

	@PutMapping("/editActivity/{id}")
	Activity editActivity(@RequestBody Activity activity, @PathVariable  long id) {
		return activityService.editActivity(activity, id);
	}

	@GetMapping("/findActivity/{id}")
	Activity findActivity(@PathVariable  long id) {
		return activityService.findActivity(id);
	}

	@DeleteMapping("/deleteActivity/{id}")
	void deleteActivity(@PathVariable  long id) {
		activityService.deleteActivity(id);
	}
	@GetMapping("/findActivitiesForSchool/{id}")
	Listélt;Activity> findActivitiesForSchool(@PathVariable  long id) {
		return activityService.findActivitiesForSchool(id);
	}

}

Here, we are creating a class CoefficientController

src/main/java/com/school/controller/CoefficientController.java):

package com.school.controller;

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.school.modal.Coefficient;
import com.school.service.CoefficientService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class CoefficientController {

 @Autowired
 private CoefficientService coefficientService;

	@PostMapping("/addCoefficient/{id}")
	Coefficient addCoefficient(@RequestBody Coefficient coefficient, @PathVariable  long id) {
		return coefficientService.addCoefficient(coefficient, id);
	}

	@PutMapping("/editCoefficient/{id}")
	Coefficient editCoefficient(@RequestBody Coefficient coefficient, @PathVariable  long id) {
		return coefficientService.editCoefficient(coefficient, id);
	}

	@GetMapping("/findCoefficient/{id}")
	Coefficient findCoefficient(@PathVariable  long id) {
		return coefficientService.findCoefficient(id);
	}

	@DeleteMapping("/deleteCoefficient/{id}")
	void deleteCoefficient(@PathVariable  long id) {
		coefficientService.deleteCoefficient(id);
	}

}

Here, we are creating a class CourseController

src/main/java/com/school/controller/CourseController.java):

package com.school.controller;

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.school.modal.Course;
import com.school.service.CourseService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class CourseController {
	
 @Autowired
 private CourseService courseService;

	@PostMapping("/addCourse/{idLevel}/{idSubject}")
	Course addCourse(@RequestBody Course course, @PathVariable  long idLevel, @PathVariable  long idSubject) {
		return courseService.addCourse(course, idLevel, idSubject);
	}
	
	@PutMapping("/editCourse/{idCourse}/{idSubject}")
	Course editCourse(@RequestBody Course course, @PathVariable  long idCourse, @PathVariable  long idSubject) {
		return courseService.editCourse(course, idCourse, idSubject);
	}
	
	@GetMapping("/findCourse/{id}")
	Course findCourse(@PathVariable  long id) {
		return courseService.findCourse(id);
	}
	
	@DeleteMapping("/deleteCourse/{idCourse}/{idSubject}")
	void deleteCourse(@PathVariable  long idCourse, @PathVariable  long idSubject) {
		courseService.deleteCourse(idCourse, idSubject);
	}

}

Here, we are creating a class ExamController

src/main/java/com/school/controller/ExamController.java):

package com.school.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.school.modal.Exam;
import com.school.service.ExamService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class ExamController {

 @Autowired
 private ExamService examService;

	@PostMapping("/addExam/{idSchool}/{idSubject}")
	Exam addExam(@RequestBody Exam exam, @PathVariable  long idSchool, @PathVariable  long idSubject) {
		return examService.addExam(exam, idSchool, idSubject);
	}

	@PutMapping("/editExam/{id}")
	Exam editExam(@RequestBody Exam exam, @PathVariable  long id) {
		return examService.editExam(exam, id);
	}

	@GetMapping("/findExam/{id}")
	Exam findExam(@PathVariable  long id) {
		return examService.findExam(id);
	}

	@DeleteMapping("/deleteExam/{id}/{idSubject}")
	void deleteExam(@PathVariable  long id, @PathVariable  long idSubject) {
		examService.deleteExam(id, idSubject);
	}
	
	@GetMapping("/findExamsForSchool/{id}")
	List<Exam> findExamsForSchool(@PathVariable  long id) {
		return examService.findExamsForSchool(id);
	}

}
 

Here, we are creating a class LevelController

src/main/java/com/school/controller/LevelController.java):

package com.school.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.school.modal.Level;
import com.school.service.LevelService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class LevelController {
	
 @Autowired
 private LevelService levelService;
	
	@PostMapping("/addLevel/{id}")
	Level addLevel(@RequestBody Level level, @PathVariable  long id) {
		return levelService.addLevel(level, id);
	}
	@PutMapping("/editLevel/{id}")
	Level editLevel(@RequestBody Level level, @PathVariable  long id) {
		return levelService.editLevel(level, id);
	}
	
	@GetMapping("/findLevel/{id}")
	Level findLevel(@PathVariable  long id) {
		return levelService.findLevel(id);
	}
	@DeleteMapping("/deleteLevel/{id}")
	void deleteLevel(@PathVariable  long id) {
		levelService.deleteLevel(id);
	}
	@PostMapping("/addLevelToRoom/{idRoom}/{idLevel}")
	void addLevelToRoom(@PathVariable  long idRoom, @PathVariable  long idLevel) {
		levelService.addLevelToRoom(idRoom, idLevel);
	}
	
	@GetMapping("/findLevels")
	List<Level> findLevels() {
		return levelService.findLevels();
	}
	@DeleteMapping("/deleteLevelFromRoom/{idRoom}/{idLevel}")
	void deleteLevelFromRoom(@PathVariable  long idRoom, @PathVariable  long idLevel)  {
	    levelService.deleteLevelFromRoom(idRoom, idLevel);
	}
	@GetMapping("/findLevelForRoom/{idRoom}")
	Level findLevelForRoom(@PathVariable  long idRoom) {
		return levelService.findLevelForRoom(idRoom);
	}
}

Here, we are creating a class ManagerConntroller

src/main/java/com/school/controller/ManagerConntroller.java):

package com.school.controller;

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.school.modal.Manager;
import com.school.service.ManagerService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class ManagerConntroller {

 @Autowired
 private ManagerService managerService;

	@PostMapping("/addManager/{id}")
	Manager addManager(@RequestBody Manager manager, @PathVariable  long id) {
		return managerService.addManager(manager, id);
	}

	@PutMapping("/editManager/{id}")
	Manager editManager(@RequestBody Manager manager, @PathVariable  long id) {
		return managerService.editManager(manager, id);
	}

	@GetMapping("/findManager/{id}")
	Manager findManager(@PathVariable  long id) {
		return managerService.findManager(id);
	}
	
	@GetMapping("/findManagerForSchool/{id}")
	Manager findManagerForSchool(@PathVariable  long id) {
		return managerService.findManagerForSchool(id);
	}

	@DeleteMapping("/deleteManager/{id}/{idSchhol}")
	void deleteManager(@PathVariable  long id, @PathVariable  long idSchool) {
		managerService.deleteManager(id, idSchhol);
	}

}

Here, we are creating a class NoteController

src/main/java/com/school/controller/NoteController.java):

package com.school.controller;

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.school.modal.Note;
import com.school.service.NoteService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class NoteController {

 @Autowired
 private NoteService noteService;

	@PostMapping("/addNote/{id}")
	Note addNote(@RequestBody Note note, @PathVariable  long id) {
		return noteService.addNote(note, id);
	}

	@PutMapping("/editNote/{id}")
	Note editNote(@RequestBody Note note, @PathVariable  long id) {
		return noteService.editNote(note, id);
	}

	@GetMapping("/findNote/{id}")
	Note findNote(@PathVariable  long id) {
		return noteService.findNote(id);
	}

	@DeleteMapping("/deleteNote/{id}")
	void deleteNote(@PathVariable  long id) {
		noteService.deleteNote(id);
	}

}

Here, we are creating a class ProgramController

src/main/java/com/school/controller/ProgramController.java):

package com.school.controller;

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.school.modal.Program;
import com.school.service.ProgramService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class ProgramController {
	
 @Autowired
 private ProgramService programService;
	
	@PostMapping("/addProgram/{id}")
	Program addProgram(@RequestBody Program program, @PathVariable  long id) {
		return programService.addProgram(program, id);
	}
	
	@PutMapping("/editProgram/{id}")
	Program editProgram(@RequestBody Program program, @PathVariable  long id) {
		return programService.editProgram(program, id);
	}
	
	@GetMapping("/findProgram/{id}")
	Program findProgram(@PathVariable  long id) {
		return programService.findProgram(id);
	}
	
	@DeleteMapping("/deleteProgram/{id}")
	void deleteProgram(@PathVariable  long id) {
		programService.deleteProgram(id);
	}

}

Here, we are creating a class RoomController

src/main/java/com/school/controller/RoomController.java):

package com.school.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.school.modal.Room;
import com.school.service.RoomService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class RoomController {

 @Autowired
 private RoomService roomService;

	@PostMapping("/addRoom/{id}")
	Room addRoom(@RequestBody Room room, @PathVariable  long id) {
		return roomService.addRoom(room, id);
	}

	@PutMapping("/editRoom/{id}")
	Room editRoom(@RequestBody Room room, @PathVariable  long id) {
		return roomService.editRoom(room, id);
	}

	@GetMapping("/findRoom/{id}")
	Room findRoom(@PathVariable  long id) {
		return roomService.findRoom(id);
	}

	@DeleteMapping("/deleteRoom/{id}")
	void deleteRoom(@PathVariable  long id) {
		roomService.deleteRoom(id);
	}
	
	@GetMapping("/findRoomsForSchool/{id}")
	List<Room> findRoomsForSchool(@PathVariable  long id) {
		return roomService.findRoomsForSchool(id);
	}
}

Here, we are creating a class SchoolController

src/main/java/com/school/controller/SchoolController.java):

package com.school.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.school.modal.School;
import com.school.service.SchoolService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class SchoolController {

 @Autowired
 private SchoolService schoolService;

	@PostMapping("/addSchool")
	School addSchool(@RequestBody School school) {
		return schoolService.addSchool(school);
	}

	@PutMapping("/editSchool/{id}")
	School editSchool(@RequestBody School school, @PathVariable  long id) {
		return schoolService.editSchool(school, id);
	}

	@GetMapping("/findSchool/{id}")
	School findSchool(@PathVariable  long id) {
		return schoolService.findSchool(id);
	}

	@DeleteMapping("/deleteSchool/{id}")
	void deleteSchool(@PathVariable  long id) {
		schoolService.deleteSchool(id);
	}

	@GetMapping("/findSchools")
	List<School> findSchools() {
		return schoolService.findSchools();
	}

}

Here, we are creating a class SchoolingController

src/main/java/com/school/controller/SchoolingController.java):

package com.school.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.school.modal.Schooling;
import com.school.service.SchoolingService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class SchoolingController {

 @Autowired
 private SchoolingService schoolingService;

	@PostMapping("/addSchooling/{id}")
	Schooling addSchooling(@RequestBody Schooling schooling, @PathVariable  long id) {
		return schoolingService.addSchooling(schooling, id);
	}

	@PutMapping("/editSchooling/{id}")
	Schooling editSchooling(@RequestBody Schooling schooling, @PathVariable  long id) {
		return schoolingService.editSchooling(schooling, id);
	}

	@GetMapping("/findSchooling/{id}")
	Schooling findSchooling(@PathVariable  long id) {
		return schoolingService.findSchooling(id);
	}

	@DeleteMapping("/deleteSchooling/{id}")
	void deleteSchooling(@PathVariable  long id) {
		schoolingService.deleteSchooling(id);
	}
	@GetMapping("/findSchoolingsForSchool/{id}")
	List<Schooling> findSchoolingsForSchool(@PathVariable  long id) {
		return schoolingService.findSchoolingsForSchool(id);
	}
}

Here, we are creating a class SubjectController

src/main/java/com/school/controller/SubjectController.java):

package com.school.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.school.modal.Subject;
import com.school.service.SubjectService;

@RestController
@RequestMapping(value = "/api")
@CrossOrigin(origins = "*")
public class SubjectController {
	
 @Autowired
 private SubjectService subjectService;
	
	@PostMapping("/addSubject/{id}")
	Subject addSubject(@RequestBody Subject subject, @PathVariable  long id) {
		return subjectService.addSubject(subject, id);
	}
	
	@PutMapping("/editSubject/{id}")
	Subject editSubject(@RequestBody Subject subject, @PathVariable  long id) {
		return subjectService.editSubject(subject, id);
	}
	
	@GetMapping("/findSubject/{id}")
	Subject findSubject(@PathVariable  long id) {
		return subjectService.findSubject(id);
	}
	
	@GetMapping("/findSubjectForExam/{id}")
	Subject findSubjectForExam(@PathVariable  long id) {
		return subjectService.findSubjectForExam(id);
	}
	
	@DeleteMapping("/deleteSubject/{id}")
	void deleteSubject(@PathVariable  long id) {
		subjectService.deleteSubject(id);
	}
	@GetMapping("/findAllSubjectsForSchool/{id}")
	List<Subject> findAllSubjectsForSchool(@PathVariable  long id) {
		return subjectService.findAllSubjectsForSchool(id);
	}
	
	@GetMapping("/findSubjectForCourse/{id}")
	Subject findSubjectForCourse(@PathVariable  long id) {
		return subjectService.findSubjectForCourse(id);
	}
	
	@GetMapping("/findSubjectsForSchool/{id}")
	List<Subject> findSubjectsForSchool(@PathVariable  long id) {
		return subjectService.findSubjectsForSchool(id);
	}

}

SchoolApplication

@BookStoreApplication 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/school/SchoolApplication.java):

package com.shcool;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;


@SpringBootApplication
public class SchoolApplication {

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

Conclusion

Now we have an overview of Spring Boot example when building a @RestController API.

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 project structure for building a front-end app to make HTTP requests and consume responses.

Building application School with Spring boot and Angular Part 3

Download This Application My School From Github