Spring Lombok

2023-12-20

Spring Lombok

In Spring, Lombok is a Java library that is used to minimize boilerplate code. It uses annotations to generate common methods like getters, setters, constructors, toString, equals, and hashCode methods during compile time. Below are some of the most common Lombok annotations and features:

Common Lombok Annotations and Features:

@NoArgsConstructor: Generates a no-arguments constructor.
@RequiredArgsConstructor: Generates a constructor with required arguments (fields marked as final or annotated with @NonNull).
@AllArgsConstructor: Generates a constructor with all fields as arguments.
@Data: Generates getter, setter, equals(), hashCode(), and toString() methods.
@Value: Similar to @Data, but generates an immutable class (all fields are final).
@Builder: Generates a builder pattern for creating complex objects.
@SneakyThrows: Automatically adds exception handling code in methods.
@Cleanup: Automatically closes resources, like file streams or database connections.
@Slf4j: Automatically generates logging code and integrates with various logging frameworks.
@EqualsAndHashCode: Generates equals() and hashCode() methods.
@ToString: Generates a toString() method.
@Getter: Generates getter methods.
@Setter: Generates setter methods.
@Delegate: Delegates method implementation to another object.
@Value.Immutable: Generates immutable value objects.
@Wither: Generates a method that returns a new instance with a specified field value changed.
@NoArgsConstructor(force = true): Generates a no-arguments constructor, even if there are final fields.

Detailed Explanation and Usage Examples:

@NoArgsConstructor, @AllArgsConstructor, and @RequiredArgsConstructor:

@NoArgsConstructor: Generates a no-arguments constructor.
@AllArgsConstructor: Generates a constructor with all fields as arguments.
@RequiredArgsConstructor: Generates a constructor with required arguments (fields marked as final or annotated with @NonNull).

import lombok.*;

@NoArgsConstructor
@AllArgsConstructor
@RequiredArgsConstructor
public class Person {
    @NonNull private String firstName;
    @NonNull private String lastName;
    private int age;
}

@Data and @Value:
- @Data: Generates getter, setter, equals(), hashCode(), and toString() methods.
- @Value: Similar to @Data, but generates an immutable class (all fields are final).
1
2
3
4
5
6
7
8
import lombok.*;

@Data
public class Book {
private String title;
private String author;
private int pageCount;
}

@Builder: Generates a builder pattern for creating complex objects.

import lombok.*;

@Builder
public class Product {
    private String name;
    private String category;
    private double price;
}

// Creating an instance using the builder pattern
Product product = Product.builder()
    .name("Widget")
    .category("Electronics")
    .price(19.99)
    .build();

@SneakyThrows: Automatically adds exception handling code in methods.

import lombok.SneakyThrows;

public class FileProcessor {
    @SneakyThrows
    public void processFile() {
        // No need to explicitly handle the exception
        throw new Exception("Something went wrong.");
    }
}

@Cleanup: Automatically closes resources, like file streams or database connections.

import lombok.Cleanup;

public class FileHandler {
    public void readFile(String filePath) {
        @Cleanup FileReader reader = new FileReader(filePath);
        // Read file
    }
}

@Slf4j: Automatically generates logging code and integrates with various logging frameworks.

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class LoggerExample {
    public void logSomething() {
        log.debug("This is a debug message.");
        log.info("This is an info message.");
    }
}

@Getter and @Setter: Generates getter and setter methods.

import lombok.Getter;
import lombok.Setter;

public class Student {
    @Getter @Setter private String name;
    @Getter @Setter private int age;
}

Using Lombok annotations can significantly reduce the amount of boilerplate code in your Java classes, making your code more concise and easier to maintain.

Custom Validation Annotations in Spring

2023-12-18

Custom Validation Annotations in Spring

1. Define the Custom Validation AnnotationCustom Validation Annotations in Spring

First, you need to define a custom annotation. This annotation should be marked with @Constraint and specify a class that implements the ConstraintValidator interface as its validator.

import javax.validation.Constraint;
import javax.validation.Payload;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Constraint(validatedBy = CourseCodeConstraintValidator.class)
@Target({ElementType.METHOD, ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface CourseCode {
    public String value() default "LUV";
    public String message() default "must start with LUV";
    public Class<?>[] groups() default {};
    public Class<? extends Payload>[] payload() default {};
}

@Constraint(validatedBy = CourseCodeConstraintValidator.class): Specifies that CourseCode is a constraint annotation and its validation logic is implemented by CourseCodeConstraintValidator.
@Target({ElementType.METHOD, ElementType.FIELD}): Indicates that the annotation can be applied to methods and fields.
@Retention(RetentionPolicy.RUNTIME): Ensures that the annotation is available at runtime.
public Class<?>[] groups() default {};: Used to specify validation groups.
public Class<? extends Payload>[] payload() default {};: Used to provide custom payload objects for the validation.

2. Create the Custom Validator

Next, create a class that implements the ConstraintValidator interface. This class contains the actual validation logic.

import javax.validation.ConstraintValidator;
import javax.validation.ConstraintValidatorContext;

public class CourseCodeConstraintValidator implements ConstraintValidator<CourseCode, String> {
    private String coursePrefix;

    @Override
    public void initialize(CourseCode theCourseCode) {
        coursePrefix = theCourseCode.value();  // Read the value attribute from the annotation
    }

    @Override
    public boolean isValid(String theCode, ConstraintValidatorContext constraintValidatorContext) {
        if (theCode != null) {
            return theCode.startsWith(coursePrefix);
        } else {
            return true;  // Assume null values are valid
        }
    }
}

CourseCodeConstraintValidator implements ConstraintValidator<CourseCode, String>.
initialize method is used to read the value attribute from the annotation.
isValid method contains the validation logic.

3. Apply the Custom Annotation

Apply the custom annotation to the fields that need to be validated.

import javax.validation.constraints.NotNull;

public class Customer {

    @CourseCode(value="TOPS", message="must start with TOPS")
    private String courseCode;

    @NotNull(message = "is required")
    private String firstName;

    // Getters and setters
    public String getCourseCode() {
        return courseCode;
    }

    public void setCourseCode(String courseCode) {
        this.courseCode = courseCode;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }
}

4. Integrate with Spring MVC

In the Spring MVC controller, use the @Valid annotation to trigger the validation process.

import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.PostMapping;

import javax.validation.Valid;

@Controller
public class CustomerController {

    @PostMapping("/processForm")
    public String processForm(@Valid @ModelAttribute("customer") Customer theCustomer, BindingResult theBindingResult) {
        if (theBindingResult.hasErrors()) {
            // Handle validation errors
            return "customer-form";
        }
        // Proceed with normal business logic
        return "customer-confirmation";
    }
}

@Valid: Enables automatic validation of the Customer object.
@ModelAttribute("customer") Customer theCustomer: Binds form data to the Customer object and validates it.
BindingResult theBindingResult: Captures the validation errors.

By following these steps, you can create and use custom validation annotations in a Spring application to ensure that your data meets specific validation criteria.

Common Data Validation Annotations in Spring MVC

2023-12-18

Common Data Validation Annotations in Spring MVC

Annotation	Description
`@NotNull`	Validates that the annotated element is not null.
`@NotEmpty`	Validates that the annotated element is not empty (not null and size > 0).
`@NotBlank`	Validates that the annotated string is not empty and contains at least one non-whitespace character.
`@Min(value)`	Validates that the annotated element’s value is greater than or equal to the specified minimum value.
`@Max(value)`	Validates that the annotated element’s value is less than or equal to the specified maximum value.
`@Size(min=, max=)`	Validates that the annotated element’s size is within the specified range (for strings, this is length; for collections, this is size).
`@Email`	Validates that the annotated element is a valid email address.
`@Positive`	Validates that the annotated element’s value is a positive number (greater than 0).
`@PositiveOrZero`	Validates that the annotated element’s value is a non-negative number (greater than or equal to 0).
`@Negative`	Validates that the annotated element’s value is a negative number (less than 0).
`@NegativeOrZero`	Validates that the annotated element’s value is a non-positive number (less than or equal to 0).
`@Pattern(regexp)`	Validates that the annotated element’s value matches the specified regular expression.
`@Digits(integer=, fraction=)`	Validates that the annotated element’s value has the specified number of integer and fractional digits.
`@AssertTrue`	Validates that the annotated element’s value is true.
`@AssertFalse`	Validates that the annotated element’s value is false.
`@Past`	Validates that the annotated element’s value is a date in the past.
`@PastOrPresent`	Validates that the annotated element’s value is a date in the past or present.
`@Future`	Validates that the annotated element’s value is a date in the future.
`@FutureOrPresent`	Validates that the annotated element’s value is a date in the present or future.

Example Usage

Here’s an example of how you can use these annotations in a model class:

import javax.validation.constraints.*;

public class User {

    @NotNull(message = "Name is required")
    private String name;

    @NotEmpty(message = "Email is required")
    @Email(message = "Email should be valid")
    private String email;

    @NotNull(message = "Age is required")
    @Min(value = 18, message = "Age should be at least 18")
    @Max(value = 65, message = "Age should be at most 65")
    private Integer age;

    @Pattern(regexp = "^[a-zA-Z0-9]{5}", message = "Postal code should be 5 characters/digits")
    private String postalCode;

    @Positive(message = "Account balance must be positive")
    private Double accountBalance;

    // Getters and setters
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }

    public Double getAccountBalance() {
        return accountBalance;
    }

    public void setAccountBalance(Double accountBalance) {
        this.accountBalance = accountBalance;
    }
}

In a Spring MVC controller, you can use the @Valid annotation to trigger validation and handle the results with a BindingResult object:

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;

import javax.validation.Valid;

@Controller
@RequestMapping("/user")
public class UserController {

    @GetMapping("/register")
    public String showRegistrationForm(Model model) {
        model.addAttribute("user", new User());
        return "user-register";
    }

    @PostMapping("/register")
    public String registerUser(@Valid @ModelAttribute("user") User user, BindingResult bindingResult) {
        if (bindingResult.hasErrors()) {
            return "user-register";
        }
        // Save user and redirect to success page
        return "redirect:/user/success";
    }

    @GetMapping("/success")
    public String showSuccessPage() {
        return "registration-success";
    }
}

By using these annotations and validation mechanisms, you can ensure that your application’s data meets the necessary constraints and handle invalid input gracefully.

Spring MVC Data Validation

2023-12-18

Spring MVC Data Validation

In Spring MVC, data validation is an essential feature to ensure that user input or submitted data adheres to predefined rules. Spring MVC integrates seamlessly with the Java Bean Validation (JSR 303 and JSR 349) API, providing a straightforward way to validate model data.

1. Add Dependencies

Add the Spring Boot Validation dependency in your pom.xml file if you are using Maven:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

2. Create the Model Class

Define fields in your model class (e.g., a form-backing object) and annotate them with appropriate Bean Validation annotations.

import javax.validation.constraints.*;

public class Customer {
    private String firstName;

    @NotNull(message = "is required")
    @Size(min = 1, message = "is required")
    private String lastName = "";

    @NotNull(message = "is required")
    @Min(value = 0, message = "must be greater than or equal to zero")
    @Max(value = 10, message = "must be less than or equal to 10")
    private Integer freePasses;

    @Pattern(regexp = "^[a-zA-Z0-9]{5}", message = "only 5 chars/digits")
    private String postalCode;

    // Getters and setters
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getFreePasses() {
        return freePasses;
    }

    public void setFreePasses(Integer freePasses) {
        this.freePasses = freePasses;
    }

    public String getPostalCode() {
        return postalCode;
    }

    public void setPostalCode(String postalCode) {
        this.postalCode = postalCode;
    }
}

3. Validation in the Controller

Use the @Valid annotation to trigger validation logic and the BindingResult object to check validation results in your Spring MVC controller.

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import org.springframework.ui.Model;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.WebDataBinder;
import org.springframework.beans.propertyeditors.StringTrimmerEditor;

import javax.validation.Valid;

@Controller
@RequestMapping("/customer")
public class CustomerController {

    // @InitBinder: Customizes the data binding process for web requests
    @InitBinder
    public void initBinder(WebDataBinder dataBinder) {
        // StringTrimmerEditor: Automatically trims white spaces for String fields
        StringTrimmerEditor stringTrimmerEditor = new StringTrimmerEditor(true);
        dataBinder.registerCustomEditor(String.class, stringTrimmerEditor);
    }

    @GetMapping("/showForm")
    public String showForm(Model model) {
        model.addAttribute("customer", new Customer());
        return "customer-form";
    }

    @PostMapping("/processForm")
    public String processForm(
            @Valid @ModelAttribute("customer") Customer theCustomer,
            BindingResult theBindingResult) {

        if (theBindingResult.hasErrors()) {
            // Handle errors
            return "customer-form";
        }

        // Normal business logic
        return "customer-confirmation";
    }
}

4. Frontend Form

Create a simple HTML form to submit customer information.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Customer Form</title>
</head>
<body>
<h2>Customer Form</h2>
<form action="#" th:action="@{/customer/processForm}" th:object="${customer}" method="post">
    <label>First Name:</label>
    <input type="text" th:field="*{firstName}" />
    <br/><br/>

    <label>Last Name:</label>
    <input type="text" th:field="*{lastName}" />
    <div th:if="${#fields.hasErrors('lastName')}" th:errors="*{lastName}">Last Name Error</div>
    <br/><br/>

    <label>Free Passes:</label>
    <input type="text" th:field="*{freePasses}" />
    <div th:if="${#fields.hasErrors('freePasses')}" th:errors="*{freePasses}">Free Passes Error</div>
    <br/><br/>

    <label>Postal Code:</label>
    <input type="text" th:field="*{postalCode}" />
    <div th:if="${#fields.hasErrors('postalCode')}" th:errors="*{postalCode}">Postal Code Error</div>
    <br/><br/>

    <input type="submit" value="Submit" />
</form>
</body>
</html>

Summary

Add Dependencies: Ensure the project includes the Spring Boot Validation dependency.
Define Model Class: Use Bean Validation annotations to define validation rules in the model class.
Controller Validation: Use the @Valid annotation and BindingResult object to perform and check validation in the controller.
Frontend Form: Create an HTML form to submit data and display validation error messages.

By following these steps, you can implement data validation in Spring MVC to ensure that input data meets predefined rules and constraints.

Spring MVC's @RestController

2023-12-17

Spring MVC’s @RestController

@RestController is an annotation in Spring MVC used to create RESTful web services. It combines the @Controller and @ResponseBody annotations, simplifying the controller implementation. Here are some key annotations related to @RestController along with their descriptions and usage:

@RestController
- Description: Indicates that the class is a controller where every method returns a domain object instead of a view. Each method’s return value is automatically serialized to JSON and written into the HTTP response body.
- Usage: Typically used to create REST APIs. Used at the class level.
  1
  2
  3
  4
  @RestController
  public class MyController {
  // ...
  }
@RequestMapping
- Description: Maps HTTP requests to handler methods of MVC and REST controllers.
- Usage: Can be used at both the class and method levels. Supports configuring URL patterns, HTTP methods, request parameters, headers, etc.
  1
  2
  3
  4
  @RequestMapping(value = "/users", method = RequestMethod.GET)
  public List<User> getUsers() {
  // ...
  }
@GetMapping, @PostMapping, @PutMapping, @DeleteMapping
- Description: Specialized versions of @RequestMapping for specific HTTP methods.
- Usage: Used at the method level, directly specifying the URL path and the HTTP method type.
  1
  2
  3
  4
  @GetMapping("/users")
  public User getUser() {
  // ...
  }
@PathVariable
- Description: Binds a method parameter to a URI template variable.
- Usage: Commonly used in RESTful web services.
  1
  2
  3
  4
  @GetMapping("/users/{id}")
  public User getUser(@PathVariable Long id) {
  // ...
  }
@RequestParam
- Description: Binds a method parameter to a web request parameter.
- Usage: Used to handle query parameters.
  1
  2
  3
  4
  @GetMapping("/users")
  public List<User> getUsers(@RequestParam String role) {
  // ...
  }
@RequestBody
- Description: Binds the HTTP request body to a method parameter.
- Usage: Commonly used in POST and PUT methods.
  1
  2
  3
  4
  @PostMapping("/users")
  public User addUser(@RequestBody User user) {
  // ...
  }
@ResponseBody
- Description: Indicates that the return value of a method should be written directly to the HTTP response body.
- Usage: In a @RestController, all methods implicitly use @ResponseBody.
  1
  2
  3
  4
  @GetMapping("/greeting")
  public String greeting() {
  return "Hello, World";
  }
@ResponseStatus
- Description: Marks a method or exception class with the status code and reason message that should be returned.
- Usage: Often used for exception handling or specific operations.
  1
  2
  3
  4
  5
  @ResponseStatus(HttpStatus.CREATED)
  @PostMapping("/users")
  public User addUser(@RequestBody User user) {
  // ...
  }
@CrossOrigin
- Description: Enables cross-origin resource sharing (CORS) for the annotated methods or types.
- Usage: Can be applied at both the class and method levels to allow cross-origin requests.
  1
  2
  3
  4
  5
  @CrossOrigin(origins = "http://example.com")
  @GetMapping("/users")
  public List<User> getUsers() {
  // ...
  }

Example of a Spring MVC Controller with @RestController

import org.springframework.web.bind.annotation.*;

import java.util.ArrayList;
import java.util.List;

@RestController
@RequestMapping("/api")
public class UserController {

    private List<User> users = new ArrayList<>();

    @GetMapping("/users")
    public List<User> getUsers() {
        return users;
    }

    @GetMapping("/users/{id}")
    public User getUser(@PathVariable int id) {
        return users.stream().filter(user -> user.getId() == id).findFirst().orElse(null);
    }

    @PostMapping("/users")
    @ResponseStatus(HttpStatus.CREATED)
    public User addUser(@RequestBody User user) {
        users.add(user);
        return user;
    }

    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable int id, @RequestBody User userDetails) {
        User user = users.stream().filter(u -> u.getId() == id).findFirst().orElse(null);
        if (user != null) {
            user.setName(userDetails.getName());
            user.setEmail(userDetails.getEmail());
        }
        return user;
    }

    @DeleteMapping("/users/{id}")
    public void deleteUser(@PathVariable int id) {
        users.removeIf(user -> user.getId() == id);
    }
}

In this example:

@RestController is used to define the controller.
Various HTTP methods (@GetMapping, @PostMapping, @PutMapping, @DeleteMapping) are used to handle different types of HTTP requests.
@RequestMapping("/api") at the class level sets the base URL for all endpoints in the controller.
@PathVariable, @RequestParam, and @RequestBody are used to handle path variables, query parameters, and request bodies, respectively.
@ResponseStatus is used to set the HTTP status code for the response.

Many to Many

2023-12-17

#Many to Many

DAO

public interface AppDAO {
    void save(Instructor theInstructor);
    Instructor findInstructorById(int theId);
    void deleteInstructorById(int theId);
  
    InstructorDetail findInstructorDetailById(int theId);
    void deleteInstructorDetailById(int theId);
  
    List<Course> findCourseByInstructorId(int theId);
    Instructor findInstructorByIdJoinFetch(int theId);
  
    void update(Instructor tempInstructor);
    void update(Course tempCourse);
  
    Course findCourseById(int theId);
    void deleteCourseById(int theId);
    void save(Course theCourse);
  
    Course findCourseAndReviewsByCourseId(int theId);
    Course findCourseAndStudentsByCourseId(int theId);
    Student findStudentAndCoursesByStudentId(int theId);
  
    void update(Student tempStudent);
    void deleteStudentById(int theId);
}

@Repository
public class AppDAOImpl implements AppDAO {

    private EntityManager entityManager;

    @Autowired
    public AppDAOImpl(EntityManager entityManager) {
        this.entityManager = entityManager;
    }

    @Override
    @Transactional
    public void save(Instructor theInstructor) {
        entityManager.persist(theInstructor);
    }

    @Override
    public Instructor findInstructorById(int theId) {
        return entityManager.find(Instructor.class, theId);
    }

    @Override
    @Transactional
    public void deleteInstructorById(int theId) {
        Instructor tempInstructor = entityManager.find(Instructor.class, theId);
        List<Course> courses = tempInstructor.getCourses();
        for (Course tempCourse : courses) {
            tempCourse.setInstructor(null);
        }
        entityManager.remove(tempInstructor);
    }

    @Override
    public InstructorDetail findInstructorDetailById(int theId) {
        return entityManager.find(InstructorDetail.class, theId);
    }

    @Override
    @Transactional
    public void deleteInstructorDetailById(int theId) {
        InstructorDetail tempInstructorDetail = entityManager.find(InstructorDetail.class, theId);
        tempInstructorDetail.getInstructor().setInstructorDetail(null);
        entityManager.remove(tempInstructorDetail);
    }

    @Override
    public List<Course> findCourseByInstructorId(int theId) {
        TypedQuery<Course> query = entityManager.createQuery(
          "from Course where instructor.id = :data", Course.class);
      
        query.setParameter("data", theId);
        List<Course> courses = query.getResultList();
        return courses;
    }

    @Override
    public Instructor findInstructorByIdJoinFetch(int theId) {
        TypedQuery<Instructor> query = entityManager.createQuery(
          "select i from Instructor i"
                + "JOIN FETCH i.courses "
                + "JOIN FETCH i.instructorDetail "
                + "where i.id = :data", Instructor.class);

        query.setParameter("data", theId);
        Instructor instructor = query.getSingleResult();
        return instructor;
    }

    @Override
    @Transactional
    public void update(Instructor tempInstructor) {
        entityManager.merge(tempInstructor);
    }

    @Override
    @Transactional
    public void update(Course tempCourse) {
        entityManager.merge(tempCourse);
    }

    @Override
    public Course findCourseById(int theId) {
        return entityManager.find(Course.class, theId);
    }

    @Override
    @Transactional
    public void deleteCourseById(int theId) {
        Course tempCourse = entityManager.find(Course.class, theId);
        entityManager.remove(tempCourse);
    }

    @Override
    @Transactional
    public void save(Course theCourse) {
        entityManager.persist(theCourse);
    }

    @Override
    public Course findCourseAndReviewsByCourseId(int theId) {
        TypedQuery<Course> query = entityManager.createQuery(
                "select c from Course c "
                        + "JOIN FETCH c.reviews "
                        + "where c.id = :data", Course.class);
      
        query.setParameter("data", theId);
        Course course = query.getSingleResult();
        return course;
    }

    @Override
    public Course findCourseAndStudentsByCourseId(int theId) {
        TypedQuery<Course> query = entityManager.createQuery(
                "select c from Course c "
                        + "JOIN FETCH c.students "
                        + "where c.id = :data", Course.class);
      
        query.setParameter("data", theId);
        Course course = query.getSingleResult();
        return course;
    }

    @Override
    public Student findStudentAndCoursesByStudentId(int theId) {
        TypedQuery<Student> query = entityManager.createQuery(
                "select s from Student s "
                        + "JOIN FETCH s.courses "
                        + "where s.id = :data", Student.class);

        query.setParameter("data", theId);
        Student student = query.getSingleResult();
        return student;
    }

    @Override
    @Transactional
    public void update(Student tempStudent) {
        entityManager.merge(tempStudent);
    }

    @Override
    @Transactional
    public void deleteStudentById(int theId) {
        Student tempStudent = entityManager.find(Student.class, theId);
        entityManager.remove(tempStudent);
    }
}

Entity

@Entity
@Table(name = "course")
public class Course {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "title")
    private String title;

    @ManyToOne(cascade = {CascadeType.PERSIST, CascadeType.MERGE, 
                          CascadeType.DETACH, CascadeType.REFRESH})
    @JoinColumn(name = "instructor_id")
    private Instructor instructor;

    @OneToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinColumn(name = "course_id")
    private List<Review> reviews;

    @ManyToMany(fetch = FetchType.LAZY, 
                cascade = {CascadeType.PERSIST, CascadeType.MERGE,
                           CascadeType.DETACH, CascadeType.REFRESH})
    @JoinTable(
            name = "course_student",
            joinColumns = @JoinColumn(name = "course_id"),
            inverseJoinColumns = @JoinColumn(name = "student_id"))
    private List<Student> students;

    public Course() {

    }

    public Course(String title) {
        this.title = title;
    }

    // getter and setter
  	// ... ...

    public void addReview(Review theReview) {
        if (reviews == null) {
            reviews = new ArrayList<>();
        }
        reviews.add(theReview);
    }

    public void addStudent(Student theStudent) {
        if (students == null) {
            students = new ArrayList<>();
        }
        students.add(theStudent);
    }

    // @Override toString()
}

@Entity
@Table(name = "instructor")
public class Instructor {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    @OneToOne(cascade = CascadeType.ALL)
    @JoinColumn(name = "instructor_detail_id")
    private InstructorDetail instructorDetail;

    @OneToMany(mappedBy = "instructor",
            fetch = FetchType.LAZY,
            cascade = {CascadeType.PERSIST, CascadeType.MERGE, 
                       CascadeType.DETACH, CascadeType.REFRESH})
    private List<Course> courses;

    public Instructor() {

    }

    public Instructor(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }

    // getter and setter
  	// ... ...

    public void add(Course tempCourse) {
        if (courses == null) {
            courses = new ArrayList<>();
        }
        courses.add(tempCourse);
        tempCourse.setInstructor(this);
    }

    // @Override toString()
}

@Entity
@Table(name="instructor_detail")
public class InstructorDetail {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private int id;

    @Column(name="youtube_channel")
    private String youtubeChannel;

    @Column(name="hobby")
    private String hobby;

    @OneToOne(mappedBy = "instructorDetail", 
              cascade = {CascadeType.DETACH,CascadeType.MERGE,
         								 CascadeType.PERSIST,CascadeType.REFRESH})
    private Instructor instructor;

    public InstructorDetail() {

    }

    public InstructorDetail(String youtubeChannel, String hobby) {
        this.youtubeChannel = youtubeChannel;
        this.hobby = hobby;
    }

    // getter and setter
  	// ... ...

    // @Override toString()
}

@Entity
@Table(name="review")
public class Review {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name="id")
    private int id;

    @Column(name="comment")
    private String comment;

    public Review() {

    }

    public Review(String comment) {
        this.comment = comment;
    }

    // getter and setter
  	// ... ...

    // @Override toString()
}

@Entity
@Table(name = "student")
public class Student {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private int id;

    @Column(name = "first_name")
    private String firstName;

    @Column(name = "last_name")
    private String lastName;

    @Column(name = "email")
    private String email;

    @ManyToMany(fetch = FetchType.LAZY,
            		cascade = {CascadeType.PERSIST, CascadeType.MERGE, 
                       		 CascadeType.DETACH, CascadeType.REFRESH})
    @JoinTable(
            name = "course_student",
            joinColumns = @JoinColumn(name = "student_id"),
            inverseJoinColumns = @JoinColumn(name = "course_id"))
    private List<Course> courses;

    public Student() {

    }

    public Student(String firstName, String lastName, String email) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.email = email;
    }
  
  	// getter and setter
  	// ... ...

    public void addCourse(Course theCourse) {
        if (courses == null) {
            courses = new ArrayList<>();
        }
        courses.add(theCourse);
    }
  
    // @Override toString()
}

Application

@SpringBootApplication
public class JpaOneToOneUniApplication {
	@Bean
	public CommandLineRunner commandLineRunner(AppDAO appDAO) {
		return runner->{
			// createInstructor(appDAO);
			// findInstructor(appDAO);
			// deleteInstructor(appDAO);
			// findInstructorDetail(appDAO);
			// deleteInstructorDetail(appDAO);

			// createInstructorWithCourses(appDAO);
			// findInstructorWithCourse(appDAO);
			// findCoursesForInstructor(appDAO);
			// findInstructorWithCourseJoinFetch(appDAO);
			// updateInstructor(appDAO);
			// updateCourse(appDAO);
			// deleteInstructor(appDAO);
			// deleteCourse(appDAO);

			// createCourseAndReviews(appDAO);
			// retrieveCourseAndReview(appDAO);
			// deleteCourseAndReviews(appDAO);

			// createCourseAndStudents(appDAO);
			// findCoursesAndStudents(appDAO);
			// findStudentAndCourses(appDAO);
			// addMoreCoursesForStudent(appDAO);
			// deleteCourse(appDAO);
			deleteStudent(appDAO);
		};
	}

	private void deleteStudent(AppDAO appDAO) {
		int theId = 1;
		appDAO.deleteStudentById(theId);
	}

	private void addMoreCoursesForStudent(AppDAO appDAO) {
		int theId = 2;
		Student tempStudent = appDAO.findStudentAndCoursesByStudentId(theId);

		Course tempCourse1 = new Course("Rubik's Cube - How to Speed Cube");
		Course tempCourse2 = new Course("Atari 2600 - Game Development");

		tempStudent.addCourse(tempCourse1);
		tempStudent.addCourse(tempCourse2);

		appDAO.update(tempStudent);
	}

	private void findStudentAndCourses(AppDAO appDAO) {
		int theId = 2;
		Student tempStudent = appDAO.findStudentAndCoursesByStudentId(theId);
	}

	private void findCoursesAndStudents(AppDAO appDAO) {
		int theId = 10;
		Course tempCourse = appDAO.findCourseAndStudentsByCourseId(theId
	}

	private void createCourseAndStudents(AppDAO appDAO) {
		Course tempCourse = new Course("Pacman - Now To Score One Million Points");

		Student tempStudent1 = new Student("John", "Doe", "john@gmail.com");
		Student tempStudent2 = new Student("Mary", "Public", "mary@gmail.com");

		tempCourse.addStudent(tempStudent1);
		tempCourse.addStudent(tempStudent2);

		appDAO.save(tempCourse);
	}

	private void deleteCourseAndReviews(AppDAO appDAO) {
		int theId = 10;
		appDAO.deleteCourseById(theId);
	}

	private void retrieveCourseAndReview(AppDAO appDAO) {
		int theId = 10;
		Course tempCourse = appDAO.findCourseAndReviewsByCourseId(theId);
	}

	private void createCourseAndReviews(AppDAO appDAO) {
		Course tempCourse = new Course("Pacman - How To Score On Million Points");
		tempCourse.addReview(new Review("Great course ... love it!"));
		tempCourse.addReview(new Review("Cool course, job well done."));
		tempCourse.addReview(new Review("What a dumb course, you are in idiot!"));
		appDAO.save(tempCourse);
	}


	private void deleteCourse(AppDAO appDAO) {
		int theId = 10;
		appDAO.deleteCourseById(theId);
	}

	private void updateCourse(AppDAO appDAO) {
		int theId = 10;
		Course tempCourse = appDAO.findCourseById(theId);
		tempCourse.setTitle("Enjoy the Simple Things");
    
		appDAO.update(tempCourse);
	}

	private void updateInstructor(AppDAO appDAO){
		int theId = 1;
		Instructor tempInstructor = appDAO.findInstructorById(theId);
		tempInstructor.setLastName("TESTER");

		appDAO.update(tempInstructor);
	}

	private void findInstructorWithCourseJoinFetch(AppDAO appDAO) {
		int theId = 1;
		Instructor tempInstructor = appDAO.findInstructorByIdJoinFetch(theId);
	}

	private void findCoursesForInstructor(AppDAO appDAO) {
		int theId = 1;
		Instructor tempInstructor = appDAO.findInstructorById(theId);

		List<Course> courses = appDAO.findCourseByInstructorId(theId);
		tempInstructor.setCourses(courses);
	}

	private void findInstructorWithCourse(AppDAO appDAO) {
		int theId = 1;
		Instructor tempInstructor = appDAO.findInstructorById(theId);
	}

	private void createInstructorWithCourses(AppDAO appDAO) {
		// new Instructor
		Instructor tempInstructor = new Instructor("Susan", "Public", "public@gmail.com");
		// new InstructorDetail
		InstructorDetail tempInstructorDetail = 
      new InstructorDetail("http://www.youtube/public", "code");

		// associate the objects
		tempInstructor.setInstructorDetail(tempInstructorDetail);

		// create courses
		Course tempCourse1 = new Course("Air Guitar");
		Course tempCourse2 = new Course("The Pinball Masterclass");

		tempInstructor.add(tempCourse1);
		tempInstructor.add(tempCourse2);
    
		appDAO.save(tempInstructor);
	}

	private void deleteInstructorDetail(AppDAO appDAO) {
		int theId = 2;
		appDAO.deleteInstructorDetailById(theId);
	}

	private void findInstructorDetail(AppDAO appDAO) {
		int theId = 2;
		InstructorDetail tempInstructorDetail = appDAO.findInstructorDetailById(theId);
	}

	private void deleteInstructor(AppDAO appDAO) {
		int theId = 1;
		appDAO.deleteInstructorById(theId);
	}

	private void findInstructor(AppDAO appDAO) {
		int theId = 1;
		Instructor tempInstructor = appDAO.findInstructorById(theId);
	}

	private void createInstructor(AppDAO appDAO) {
		// new Instructor
		Instructor tempInstructor = new Instructor("Chad", "Darby", "darby@gmail.com");
		// new InstructorDetail
		InstructorDetail tempInstructorDetail = 
      new InstructorDetail("http://www.youtube/darby", "code");

		// associate the objects
		tempInstructor.setInstructorDetail(tempInstructorDetail);
		appDAO.save(tempInstructor);
	}
}

Spring Core

2023-12-12

#Spring Core

interface

1
2
3

public interface Coach {
    String getDailyWorkout();
}

@Component

@Component
//@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class BaseballCoach implements Coach {
    @Override
    public String getDailyWorkout() {
        return "Spend 30 minutes in batting practice";
    }
}

@Component
public class CricketCoach implements Coach {
    @Override
    public String getDailyWorkout() {
        return "Practice fast bowling for 15 minutes";
    }
}

@Component
public class TennisCoach implements Coach {
    @Override
    public String getDailyWorkout() {
        return "Practice your backhand volley";
    }
}

@Autowired

@RestController
public class DemoController {
    // define a private field for the dependency
    private Coach myCoach;

    // define a constructor for dependency injection
    @Autowired
    public void setCoach(@Qualifier("baseballCoach") Coach theCoach) {
        myCoach = theCoach;
    }

    @GetMapping("/dailyworkout")
    public String getDailyWorkout() {
        return myCoach.getDailyWorkout();
    }
}

@Configuration and @Bean

public class SwimCoach implements Coach {
    @Override
    public String getDailyWorkout() {
        return "Swim 1000 meters as a warm up";
    }
}


@Configuration
public class SportConfig {
    @Bean
    public Coach swimCoach(){
        return new SwimCoach();
    }
}

Spring CommandLineRunner and ApplicationRunner

2023-12-09

Spring CommandLineRunner and ApplicationRunner

In Spring Boot, CommandLineRunner and ApplicationRunner are two interfaces used to run specific blocks of code after the application has started. They are commonly used for initialization tasks, such as loading data, checking system status, or performing some automated tasks.

CommandLineRunner

Purpose: All beans implementing the CommandLineRunner interface will be run after the Spring Boot application has started and is ready.
Method: It has a single method run(String... args) that receives the command-line arguments passed to the application.

Example:

import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

@Component
public class MyCommandLineRunner implements CommandLineRunner {
    @Override
    public void run(String... args) {
        // Initialization code here
        System.out.println("CommandLineRunner is executing");
    }
}

In this example, the MyCommandLineRunner class implements the CommandLineRunner interface and overrides the run method. The code inside the run method will be executed when the application starts.

ApplicationRunner

Purpose: Similar to CommandLineRunner, ApplicationRunner is also used to execute code after the Spring Boot application has started.
Method: It has a single method run(ApplicationArguments args) that provides a more structured way to access command-line arguments.

Example:

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.stereotype.Component;

@Component
public class MyAppRunner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) {
        // Initialization code here
        System.out.println("ApplicationRunner is executing");
    }
}

In this example, the MyAppRunner class implements the ApplicationRunner interface and overrides the run method. ApplicationArguments provides more detailed access to the command-line arguments, such as distinguishing between named and unnamed arguments.

Choosing Between CommandLineRunner and ApplicationRunner

The main difference between the two interfaces is how they handle command-line arguments. If you need a simple string array (e.g., standard command-line arguments), CommandLineRunner is sufficient. If you need more complex functionality, such as distinguishing between option arguments and non-option arguments or converting arguments to specific types, then ApplicationRunner is more suitable.

In a Spring Boot application, you can choose one or both interfaces to implement beans that will run initialization tasks based on your needs.

Spring application.properties

2023-12-08

Spring application.properties

In a Spring Boot application, the application.properties file is an essential configuration file used to define various settings such as database connection information, server port, logging configuration, and more. This file is typically located in the src/main/resources directory.

Here are some common configuration items found in the application.properties file:

1. Database Connection Configuration

Used to configure the details of the data source, such as URL, username, password, and Hibernate dialect for a specific database.

# DataSource Configuration
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

# JPA / Hibernate Configuration
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL5Dialect

2. Server Configuration

Set the server port and context path.

# Server Port
server.port=8080 # The port on which the application will run

# Context Path
server.servlet.context-path=/myapp # The base URL path for the application

3. Logging Configuration

Configure the logging level.

# Logging Levels
logging.level.org.springframework=INFO  # Log level for Spring framework
logging.level.com.mycompany.mypackage=DEBUG # Log level for a specific package
logging.level.root=WARN # Reduce logging level to WARN

4. Spring Boot Specific Configuration

Configure Spring Boot features such as the startup banner.

1 2	# Disable Startup Banner spring.main.banner-mode=off

5. Custom Application Configuration

Define application-specific configurations.

1
2
3

# Custom Application Configuration
myapp.feature-x.enabled=true        # Whether a custom feature is enabled
myapp.message-of-the-day=Hello World # Custom message

6. Security Configuration

Configure Spring Security related properties.

1
2
3

# Spring Security
spring.security.user.name=admin   # Default username
spring.security.user.password=secret # Default password

7. Service Discovery and Registration

If your application is part of a microservice architecture and uses a service discovery mechanism.

1
2
3

# Service Registration and Discovery
spring.application.name=my-service-name # Application name
eureka.client.serviceUrl.defaultZone=http://localhost:8761/eureka/ # Eureka server URL

8. Message Queue Configuration

Configure message queues (such as RabbitMQ, Kafka) related properties.

# RabbitMQ
spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest

These configuration items are loaded when the application starts and can be accessed in the application using annotations like @Value or configuration classes.

The actual configuration items will depend on the needs and frameworks used by your application. Spring Boot provides a wide range of configuration options, covering data sources, transaction management, message queues, security settings, custom application parameters, and more.

Aspect

2023-12-05

Aspect

@Aspect
public class LuvAopExpressions {
    @Pointcut("execution(* com.lydia.myFirstAOP.dao.*.*(..))")
    public void forDaoPackage(){}

    // create a pointcut for getter methods
    @Pointcut("execution(* com.lydia.myFirstAOP.dao.*.get*(..))")
    public void getter(){

    }

    @Pointcut("execution(* com.lydia.myFirstAOP.dao.*.set*(..))")
    public void setter(){

    }

    // create pointcut: include package ...exclude getter/setter
    @Pointcut("forDaoPackage() && !(getter() || setter())")
    public void forDaoPackageNoGetterSetter(){

    }
}

@Aspect
@Component
@Order(3)
public class MyApiAnalyticsAspect {
    @Before("com.lydia.myFirstAOP.aspect.LuvAopExpressions.forDaoPackageNoGetterSetter()")
    public void performApiAnalytics() {
        System.out.println("\n=====>> Performing API analytics");
    }
}

@Aspect
@Component
@Order(1)
public class MyCloudLogAsyncAspect {
    @Before("com.lydia.myFirstAOP.aspect.LuvAopExpressions.forDaoPackageNoGetterSetter()")
    public void logToCloudAsync() {
        System.out.println("\n=====>> Logging to Cloud in async fashion");
    }
}

@Aspect
@Component
@Order(2)
public class MyDemoLoggingAspect {

    @Around("execution(* com.lydia.myFirstAOP.service.*.getFortune(..))")
    public Object aroundGetFortune(ProceedingJoinPoint theProceedingJoinPoint) throws Throwable {
        String method = theProceedingJoinPoint.getSignature().toShortString();
        System.out.println("\n====>>> Executing @Around on method: " + method);

        long begin = System.currentTimeMillis();

        Object result = null;
        try{
            result = theProceedingJoinPoint.proceed();
        }
        catch (Exception exc) {
            System.out.println(exc.getMessage());
            // result = "Major accident! your private AOP helicopter is on the way!";
            throw exc;
        }

        long end = System.currentTimeMillis();
        long duration = end - begin;
        System.out.println("\n====>>> Duration: " + duration / 1000.0 + " seconds");

        return result;
    }

    @After("execution(* com.lydia.myFirstAOP.dao.*.findAccounts(..))")
    public void afterFinallyFindAccountsAdvice(JoinPoint theJoinPoint) {
        String method = theJoinPoint.getSignature().toShortString();
        System.out.println("\n====>>> Executing @After (finnaly) on method: " + method);
    }

    @AfterThrowing(
            pointcut = "execution(* com.lydia.myFirstAOP.dao.*.findAccounts(..))",
            throwing = "theExc"
    )
   public void afterThrowingFindAccountsAdvice(JoinPoint theJoinPoint, Throwable theExc) {
        String method = theJoinPoint.getSignature().toShortString();
        System.out.println("\n====>>> Executing @AfterThrowing on method: " + method);
        System.out.println("\n====>>> The exception is: " + theExc);
    }

    @AfterReturning(
            pointcut = "execution(* com.lydia.myFirstAOP.dao.*.findAccounts(..))",
            returning = "result"
    )
    public void afterReturningFindAccountsAdvice(JoinPoint theJoinPoint, List<Account> result) {
        String method = theJoinPoint.getSignature().toShortString();
        System.out.println("\n====>>> Executing @AfterReturning on method: " + method);
        System.out.println("\n====>>> result is: " + result);

        convertAccountNamesToUpperCase(result);
        System.out.println("\n====>>> result is: " + result);
    }

    private void convertAccountNamesToUpperCase(List<Account> result) {
        for (Account tempAccount : result) {
            String theUpperName = tempAccount.getName().toUpperCase();
            tempAccount.setName(theUpperName);
        }
    }

    @Before("com.lydia.myFirstAOP.aspect.LuvAopExpressions.forDaoPackageNoGetterSetter()")
    public void beforeAddAccountAdvice(JoinPoint theJoinPoint) {
        System.out.println("\n=====>> Executing @Before advice on method");

        // display the method signature
        MethodSignature methodSignature = (MethodSignature) theJoinPoint.getSignature();
        System.out.println("Method: " + methodSignature);

        // get args
        Object[] args = theJoinPoint.getArgs();

        // loop thru args
        for (Object tempArg : args) {
            System.out.println(tempArg);

            if (tempArg instanceof Account) {
                Account theAccount = (Account) tempArg;
                System.out.println("account name: " + theAccount.getName());
                System.out.println("account level: " + theAccount.getLevel());
            }
        }
    }
}