### Updating the Database Schema to Include Follower Relationships Now that we've implemented the FollowerService, let's update the database schema to properly represent follower relationships. This involves creating the appropriate entities and relationships using JPA annotations. #### Step 1: Create the Follower Entity First, let's create the Follower entity that will represent the many-to-many relationship between users: ```java // src/main/java/com/socialmedia/entities/Follower.java package com.socialmedia.entities; import jakarta.persistence.*; import java.io.Serializable; import java.util.Objects; @Entity @Table(name = "followers") public class Follower implements Serializable { @EmbeddedId private FollowerId id; @ManyToOne @JoinColumn(name = "follower_id", nullable = false) private User follower; @ManyToOne @JoinColumn(name = "following_id", nullable = false) private User following; // No-arg constructor for JPA public Follower() {} public Follower(User follower, User following) { this.follower = follower; this.following = following; this.id = new FollowerId(follower.getId(), following.getId()); } // Getters and Setters public FollowerId getId() { return id; } public void setId(FollowerId id) { this.id = id; } public User getFollower() { return follower; } public void setFollower(User follower) { this.follower = follower; } public User getFollowing() { return following; } public void setFollowing(User following) { this.following = following; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; Follower follower = (Follower) o; return Objects.equals(id, follower.id); } @Override public int hashCode() { return Objects.hash(id); } } ``` #### Step 2: Create the Embedded ID Class Create a separate class for the composite primary key: ```java // src/main/java/com/socialmedia/entities/FollowerId.java package com.socialmedia.entities; import jakarta.persistence.Embeddable; import java.io.Serializable; import java.util.Objects; @Embeddable public class FollowerId implements Serializable { @Column(name = "follower_id") private Long followerId; @Column(name = "following_id") private Long followingId; // No-arg constructor for JPA public FollowerId() {} public FollowerId(Long followerId, Long followingId) { this.followerId = followerId; this.followingId = followingId; } // Getters and Setters public Long getFollowerId() { return followerId; } public void setFollowerId(Long followerId) { this.followerId = followerId; } public Long getFollowingId() { return followingId; } public void setFollowingId(Long followingId) { this.followingId = followingId; } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; FollowerId that = (FollowerId) o; return Objects.equals(followerId, that.followerId) && Objects.equals(followingId, that.followingId); } @Override public int hashCode() { return Objects.hash(followerId, followingId); } } ``` #### Step 3: Update the User Entity Modify the User entity to include relationships for followers and following users: ```java // src/main/java/com/socialmedia/entities/User.java package com.socialmedia.entities; import jakarta.persistence.*; import java.util.HashSet; import java.util.Set; import java.util.Objects; @Entity @Table(name = "users") public class User extends BaseEntity { @Column(nullable = false, unique = true) private String username; @Column(nullable = false) private String password; @Column(nullable = false, unique = true) private String email; @ManyToMany @JoinTable( name = "followers", joinColumns = @JoinColumn(name = "following_id"), inverseJoinColumns = @JoinColumn(name = "follower_id") ) private Set followers = new HashSet<>(); @ManyToMany @JoinTable( name = "followers", joinColumns = @JoinColumn(name = "follower_id"), inverseJoinColumns = @JoinColumn(name = "following_id") ) private Set following = new HashSet<>(); // Getters and Setters public String getUsername() { return username; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } public Set getFollowers() { return followers; } public void setFollowers(Set followers) { this.followers = followers; } public Set getFollowing() { return following; } public void setFollowing(Set following) { this.following = following; } // Add convenience methods for managing relationships public void addFollower(User user) { this.followers.add(user); } public void removeFollower(User user) { this.followers.remove(user); } public void addFollowing(User user) { this.following.add(user); } public void removeFollowing(User user) { this.following.remove(user); } @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; User user = (User) o; return Objects.equals(id, user.id); } @Override public int hashCode() { return Objects.hash(id); } } ``` #### Step 4: Create the Follower Repository Create a repository interface for the Follower entity: ```java // src/main/java/com/socialmedia/repositories/FollowerRepository.java package com.socialmedia.repositories; import com.socialmedia.entities.Follower; import org.springframework.data.jpa.repository.JpaRepository; import org.springframework.data.jpa.repository.Query; import org.springframework.stereotype.Repository; import java.util.List; import java.util.Optional; @Repository public interface FollowerRepository extends JpaRepository { @Query("SELECT f FROM Follower f WHERE f.follower.username = ?1 AND f.following.id = ?2") Optional findByFollowerUsernameAndFollowingId(String username, Long followingId); @Query("SELECT f FROM Follower f WHERE f.following.id = ?1") List findByFollowingId(Long followingId); @Query("SELECT f FROM Follower f WHERE f.follower.id = ?1") List findByFollowerId(Long followerId); @Query("SELECT COUNT(f) FROM Follower f WHERE f.following.id = ?1") int countFollowers(Long followingId); @Query("SELECT COUNT(f) FROM Follower f WHERE f.follower.id = ?1") int countFollowing(Long followerId); } ``` ### Key Points in the Database Schema 1. **Composite Primary Key**: We're using a composite primary key (FollowerId) to uniquely identify each follower relationship. 2. **Many-to-Many Relationship**: The User entity has two collections - followers and following - which represent the many-to-many relationship. 3. **Join Tables**: The @JoinTable annotation is used to define the join tables for the many-to-many relationships. 4. **Repository Methods**: The FollowerRepository includes custom query methods for common operations like finding followers by username and following ID. ### Next Steps 1. **Implement Follower Service Methods**: Use the FollowerRepository in the FollowerService to implement follow/unfollow functionality. 2. **Create News Feed Page**: Create a new controller endpoint and service method to fetch posts from users you're following. 3. **Add Follow Button**: Update the profile page template to include a follow button that triggers the follow/unfollow action. ### Enhancements - **Caching**: Implement caching for follower counts and relationships to improve performance. - **Real-time Notifications**: Add real-time notifications when someone follows you. - **Follower Suggestions**: Implement a feature that suggests users to follow based on mutual connections. ### Further Reading - [JPA Many-to-Many Relationships](https://docs.oracle.com/cd/E16439_01/appdev.11/e13981/fundamentals.htm#CHDJEGCI) - [Spring Data JPA Repositories](https://docs.spring.io/spring-data/jpa/docs/current/reference/html/#repositories) - [Composite Primary Keys in JPA](https://www.baeldung.com/jpa-composite-primary-keys)