# Social Media Platform

Below is a comprehensive low-level design for a social media platform implemented in Java. The design covers core entities and their relationships, how posts (with comments and likes) are managed, and how user interactions (profiles, friendships, notifications) work. In this design, several design patterns are employed to keep the system modular, maintainable, and scalable. The complete solution includes detailed code with inline comments explaining the design patterns used.

***

### 1. Overview

The social media platform consists of several core entities:

* **User**: Represents a user profile that can create posts, add friends, and receive notifications.
* **Post**: Represents a post created by a user. A post can have comments and likes.
* **Comment**: Represents user comments on posts.
* **Notification**: Represents alerts for events like new friend requests or comments on a post.

#### Entities and Relationships

* **User ↔ Post**:\
  A user can create many posts. Each post is associated with one user (the author).
* **Post ↔ Comment**:\
  A post can have multiple comments. Each comment is linked to a specific post and created by a user.
* **Post ↔ Like**:\
  Users can like posts; likes are stored (typically as a set of user IDs) for each post.
* **User ↔ Friendship**:\
  Users can have friendships, which are maintained as lists (or sets) of friend references.
* **User ↔ Notification**:\
  When an event occurs (like receiving a comment or friend request), a notification is sent to the user. This is achieved using the **Observer Pattern**.

***

### 2. Management for Posts

* **Creation and Management**:\
  The **Factory Pattern** is used to encapsulate the creation of posts, ensuring that all new posts are created with proper initialization (e.g., generating unique IDs).
* **Comments and Likes**:\
  Each `Post` object maintains its own list of `Comment` objects and a set of user references for likes. Methods are provided to add a comment or register a like.
* **Scalability Considerations**:
  * **Caching**: Frequently accessed posts might be cached.
  * **Database Sharding**: Posts and comments can be stored in a distributed datastore.
  * **Asynchronous Processing**: Notifications (for new comments or likes) can be handled asynchronously.
  * **DAO/Repository Pattern**: Abstracts the data access layer, making it easier to swap out storage mechanisms as the system scales.

***

### 3. User Interaction

* **User Profile System**:\
  Each user profile contains basic information as well as collections for posts, friends, and notifications.
* **Friendships**:\
  Friend relationships are maintained by storing friend references within each user profile. When a friend request is accepted, both users are notified.
* **Notifications (Observer Pattern)**:\
  The system uses a dedicated `NotificationService` that acts as an observer. When a user action (like posting, commenting, or liking) occurs, the service sends notifications to relevant users.

***

### 4. Design Patterns Used

1. **Factory Pattern**
   * **Usage:** `PostFactory` encapsulates the logic of creating posts.
   * **Benefit:** Centralizes post creation logic, making it easier to extend the creation process (for example, creating different types of posts).
2. **Singleton Pattern**
   * **Usage:** `NotificationService` ensures a single instance is used for handling notifications across the entire application.
   * **Benefit:** Guarantees a single point of access for notification management, avoiding redundant instances.
3. **Observer Pattern**
   * **Usage:** `NotificationService` notifies users when events occur (e.g., new comments or likes).
   * **Benefit:** Decouples the notification mechanism from core business logic, allowing flexible and scalable update propagation.
4. **DAO/Repository Pattern**
   * **Usage:** `UserRepository` and `PostRepository` abstract data storage and retrieval.
   * **Benefit:** Isolates persistence logic, enhancing maintainability and allowing for easier scalability changes (like moving from in-memory to distributed storage).
5. **Service Layer**
   * **Usage:** Classes like `FriendService` and `PostService` encapsulate business logic and operations.
   * **Benefit:** Separates concerns by isolating business operations from data access and entity definitions.

***

### 5. Detailed Java Code

Below is the detailed Java implementation that brings together the design concepts and patterns described above.

```java
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;

// --------------------- ENTITIES ---------------------

// User entity representing a user profile.
// Maintains lists for friends, posts, and notifications.
class User {
    private String id;
    private String username;
    private String email;
    private Set<User> friends = new HashSet<>();
    private List<Post> posts = new ArrayList<>();
    private List<Notification> notifications = new ArrayList<>();

    public User(String id, String username, String email) {
        this.id = id;
        this.username = username;
        this.email = email;
    }

    // Adds a friend to this user.
    public void addFriend(User friend) {
        friends.add(friend);
    }

    // Associates a new post with this user.
    public void addPost(Post post) {
        posts.add(post);
    }

    // Adds a notification for this user.
    public void addNotification(Notification notification) {
        notifications.add(notification);
    }

    // Getters for demonstration purposes.
    public String getUsername() { return username; }
    public List<Notification> getNotifications() { return notifications; }
    public Set<User> getFriends() { return friends; }
}

// Post entity representing content created by a user.
// Uses a thread-safe set for likes and maintains a list of comments.
class Post {
    private String postId;
    private User author;
    private String content;
    private List<Comment> comments = new ArrayList<>();
    private Set<User> likes = ConcurrentHashMap.newKeySet();

    public Post(String postId, User author, String content) {
        this.postId = postId;
        this.author = author;
        this.content = content;
    }

    // Adds a comment and notifies the post's author.
    public void addComment(Comment comment) {
        comments.add(comment);
        // Observer Pattern: notify the author when a new comment is added.
        NotificationService.getInstance().notifyUser(author, 
            new Notification(comment.getAuthor().getUsername() + " commented on your post."));
    }

    // Registers a like and notifies the post's author if the like is new.
    public void addLike(User user) {
        if (likes.add(user)) { // Only notify if the like was successfully added.
            // Observer Pattern: notify the author about the new like.
            NotificationService.getInstance().notifyUser(author, 
                new Notification(user.getUsername() + " liked your post."));
        }
    }

    // Getters for demonstration purposes.
    public String getPostId() { return postId; }
    public User getAuthor() { return author; }
}

// Comment entity representing a comment on a post.
class Comment {
    private String commentId;
    private User author;
    private String text;
    private Date createdAt;

    public Comment(String commentId, User author, String text) {
        this.commentId = commentId;
        this.author = author;
        this.text = text;
        this.createdAt = new Date();
    }

    public String getText() { return text; }
    public User getAuthor() { return author; }
}

// Notification entity representing user alerts.
class Notification {
    private String notificationId;
    private String message;
    private boolean isRead;

    public Notification(String message) {
        this.notificationId = UUID.randomUUID().toString();
        this.message = message;
        this.isRead = false;
    }

    public String getMessage() { return message; }
    public void markAsRead() { isRead = true; }
}

// --------------------- FACTORIES ---------------------

// Factory Pattern for creating posts.
// Centralizes post creation logic to ensure proper initialization.
class PostFactory {
    public static Post createPost(User author, String content) {
        String postId = UUID.randomUUID().toString();
        Post post = new Post(postId, author, content);
        // Associate the newly created post with its author.
        author.addPost(post);
        return post;
    }
}

// --------------------- SERVICES ---------------------

// NotificationService uses both Singleton and Observer patterns.
// It serves as the central hub for dispatching notifications.
class NotificationService {
    private static NotificationService instance;

    // Private constructor enforces Singleton property.
    private NotificationService() { }

    public static synchronized NotificationService getInstance() {
        if (instance == null) {
            instance = new NotificationService();
        }
        return instance;
    }

    // Notifies a user by adding a notification and simulating an update push.
    public void notifyUser(User user, Notification notification) {
        user.addNotification(notification);
        // Observer Pattern: In a real application, additional logic might push notifications to a UI.
        System.out.println("Notification to " + user.getUsername() + ": " + notification.getMessage());
    }
}

// FriendService manages friend requests and friendships.
// This service encapsulates the business logic related to user relationships.
class FriendService {
    private static FriendService instance;

    private FriendService() { }

    public static synchronized FriendService getInstance() {
        if (instance == null) {
            instance = new FriendService();
        }
        return instance;
    }

    // Simulate sending a friend request.
    public void sendFriendRequest(User fromUser, User toUser) {
        // In a complete system, store and later validate friend requests.
        System.out.println(fromUser.getUsername() + " sent a friend request to " + toUser.getUsername());
    }

    // Accept a friend request and establish a bidirectional friendship.
    public void acceptFriendRequest(User user1, User user2) {
        user1.addFriend(user2);
        user2.addFriend(user1);
        // Observer Pattern: Notify both users about the new friendship.
        NotificationService.getInstance().notifyUser(user1, 
            new Notification("You are now friends with " + user2.getUsername()));
        NotificationService.getInstance().notifyUser(user2, 
            new Notification("You are now friends with " + user1.getUsername()));
    }
}

// PostService encapsulates post-related operations.
// It uses the Factory Pattern to create posts and includes methods to add comments and likes.
class PostService {
    private static PostService instance;

    private PostService() { }

    public static synchronized PostService getInstance() {
        if (instance == null) {
            instance = new PostService();
        }
        return instance;
    }

    // Create a new post using the PostFactory.
    public Post createPost(User author, String content) {
        return PostFactory.createPost(author, content);
    }

    // Add a comment to a post.
    public void addComment(Post post, Comment comment) {
        post.addComment(comment);
    }

    // Add a like to a post.
    public void addLike(Post post, User user) {
        post.addLike(user);
    }
}

// --------------------- REPOSITORIES (DAO/Repository Pattern) ---------------------

// UserRepository manages user data using an in-memory store.
class UserRepository {
    private static UserRepository instance;
    private Map<String, User> userStore = new HashMap<>();

    private UserRepository() { }

    public static synchronized UserRepository getInstance() {
        if (instance == null) {
            instance = new UserRepository();
        }
        return instance;
    }

    public void addUser(User user) {
        userStore.put(user.getUsername(), user);
    }

    public User getUser(String username) {
        return userStore.get(username);
    }
}

// PostRepository manages post data.
class PostRepository {
    private static PostRepository instance;
    private Map<String, Post> postStore = new HashMap<>();

    private PostRepository() { }

    public static synchronized PostRepository getInstance() {
        if (instance == null) {
            instance = new PostRepository();
        }
        return instance;
    }

    public void addPost(Post post) {
        postStore.put(post.getPostId(), post);
    }

    public Post getPost(String postId) {
        return postStore.get(postId);
    }
}

// --------------------- MAIN APPLICATION ---------------------

public class SocialMediaApp {
    public static void main(String[] args) {
        // Initialize repositories and services (Singleton pattern)
        UserRepository userRepo = UserRepository.getInstance();
        PostRepository postRepo = PostRepository.getInstance();
        FriendService friendService = FriendService.getInstance();
        PostService postService = PostService.getInstance();
        
        // Create users
        User alice = new User(UUID.randomUUID().toString(), "Alice", "alice@example.com");
        User bob = new User(UUID.randomUUID().toString(), "Bob", "bob@example.com");
        
        // Store users in the repository
        userRepo.addUser(alice);
        userRepo.addUser(bob);
        
        // Manage friendships: send and accept a friend request.
        friendService.sendFriendRequest(alice, bob);
        friendService.acceptFriendRequest(alice, bob);
        
        // Alice creates a post using PostService
        Post alicePost = postService.createPost(alice, "Hello, world! This is my first post.");
        postRepo.addPost(alicePost);
        
        // Bob interacts with Alice's post: commenting and liking
        Comment bobComment = new Comment(UUID.randomUUID().toString(), bob, "Nice post, Alice!");
        postService.addComment(alicePost, bobComment);
        postService.addLike(alicePost, bob);
        
        // Display notifications for both users
        System.out.println("\n--- Alice's Notifications ---");
        for (Notification n : alice.getNotifications()) {
            System.out.println(n.getMessage());
        }
        
        System.out.println("\n--- Bob's Notifications ---");
        for (Notification n : bob.getNotifications()) {
            System.out.println(n.getMessage());
        }
    }
}
```

***

### 6. Summary

* **Core Entities & Relationships:**\
  The code defines **User**, **Post**, **Comment**, and **Notification** entities. Relationships such as user-to-post and post-to-comment are modeled through direct associations in the class definitions.
* **Design Patterns:**
  * **Factory Pattern:** Implemented in `PostFactory` to centralize and simplify post creation.
  * **Singleton Pattern:** Used in services like `NotificationService`, `FriendService`, `PostService`, and the repositories to ensure a single instance across the application.
  * **Observer Pattern:** Integrated within `NotificationService` to update users when events occur (e.g., new comments or likes).
  * **DAO/Repository Pattern:** Represented by `UserRepository` and `PostRepository` to abstract data persistence and enable scalability.
* **Scalability & Maintainability:**\
  The design anticipates scalability challenges by suggesting practices such as caching, database sharding, asynchronous processing, and a robust DAO layer. The clear separation of concerns and the use of established design patterns make the system easier to maintain and extend.

This detailed design and code sample provide a solid blueprint for developing a scalable and maintainable social media platform in Java.
