Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-opus-4-20250514· AnthropicHugging Face LMArena Human Preference 140K

write a backend in java that holds users posts/messages, like how twitter works

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with DeepSeekdeepseek-v3-0324’s answer.
  1. User

    write a backend in java that holds users posts/messages, like how twitter works

  2. Claude Assistant

    I'll help you create a Java backend for a Twitter-like messaging system. Here's a comprehensive implementation using Spring Boot with REST APIs, JPA for database operations, and a clean architecture.

    Project Structure

    First, let's set up the Maven dependencies in pom.xml:

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
             http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>3.2.0</version>
        </parent>
        
        <groupId>com.example</groupId>
        <artifactId>social-media-backend</artifactId>
        <version>1.0.0</version>
        
        <properties>
            <java.version>17</java.version>
        </properties>
        
        <dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-data-jpa</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-validation</artifactId>
            </dependency>
            <dependency>
                <groupId>com.h2database</groupId>
                <artifactId>h2</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
        </dependencies>
    </project>
    

    Entity Models

    // User.java
    package com.example.social.entity;
    
    import jakarta.persistence.*;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.AllArgsConstructor;
    import java.time.LocalDateTime;
    import java.util.ArrayList;
    import java.util.List;
    
    @Entity
    @Table(name = "users")
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class User {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        
        @Column(unique = true, nullable = false)
        private String username;
        
        @Column(nullable = false)
        private String email;
        
        private String displayName;
        
        private String bio;
        
        @Column(nullable = false)
        private LocalDateTime createdAt;
        
        @OneToMany(mappedBy = "author", cascade = CascadeType.ALL)
        private List<Post> posts = new ArrayList<>();
        
        @ManyToMany
        @JoinTable(
            name = "user_followers",
            joinColumns = @JoinColumn(name = "user_id"),
            inverseJoinColumns = @JoinColumn(name = "follower_id")
        )
        private List<User> followers = new ArrayList<>();
        
        @ManyToMany(mappedBy = "followers")
        private List<User> following = new ArrayList<>();
        
        @PrePersist
        protected void onCreate() {
            createdAt = LocalDateTime.now();
        }
    }
    
    // Post.java
    package com.example.social.entity;
    
    import jakarta.persistence.*;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.AllArgsConstructor;
    import java.time.LocalDateTime;
    import java.util.ArrayList;
    import java.util.List;
    
    @Entity
    @Table(name = "posts")
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Post {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        
        @Column(nullable = false, length = 280)
        private String content;
        
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "author_id", nullable = false)
        private User author;
        
        @Column(nullable = false)
        private LocalDateTime createdAt;
        
        private LocalDateTime updatedAt;
        
        @OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
        private List<Like> likes = new ArrayList<>();
        
        @OneToMany(mappedBy = "parentPost", cascade = CascadeType.ALL)
        private List<Post> replies = new ArrayList<>();
        
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "parent_post_id")
        private Post parentPost;
        
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "repost_of_id")
        private Post repostOf;
        
        private int likeCount = 0;
        private int replyCount = 0;
        private int repostCount = 0;
        
        @PrePersist
        protected void onCreate() {
            createdAt = LocalDateTime.now();
        }
        
        @PreUpdate
        protected void onUpdate() {
            updatedAt = LocalDateTime.now();
        }
    }
    
    // Like.java
    package com.example.social.entity;
    
    import jakarta.persistence.*;
    import lombok.Data;
    import lombok.NoArgsConstructor;
    import lombok.AllArgsConstructor;
    import java.time.LocalDateTime;
    
    @Entity
    @Table(name = "likes", uniqueConstraints = {
        @UniqueConstraint(columnNames = {"user_id", "post_id"})
    })
    @Data
    @NoArgsConstructor
    @AllArgsConstructor
    public class Like {
        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        private Long id;
        
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "user_id", nullable = false)
        private User user;
        
        @ManyToOne(fetch = FetchType.LAZY)
        @JoinColumn(name = "post_id", nullable = false)
        private Post post;
        
        @Column(nullable = false)
        private LocalDateTime createdAt;
        
        @PrePersist
        protected void onCreate() {
            createdAt = LocalDateTime.now();
        }
    }
    

    Repository Layer

    // UserRepository.java
    package com.example.social.repository;
    
    import com.example.social.entity.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    import java.util.Optional;
    
    @Repository
    public interface UserRepository extends JpaRepository<User, Long> {
        Optional<User> findByUsername(String username);
        boolean existsByUsername(String username);
        boolean existsByEmail(String email);
    }
    
    // PostRepository.java
    package com.example.social.repository;
    
    import com.example.social.entity.Post;
    import com.example.social.entity.User;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.Pageable;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.data.jpa.repository.Query;
    import org.springframework.stereotype.Repository;
    
    @Repository
    public interface PostRepository extends JpaRepository<Post, Long> {
        Page<Post> findByAuthorOrderByCreatedAtDesc(User author, Pageable pageable);
        
        Page<Post> findByParentPostIsNullOrderByCreatedAtDesc(Pageable pageable);
        
        @Query("SELECT p FROM Post p WHERE p.author IN :users AND p.parentPost IS NULL ORDER BY p.createdAt DESC")
        Page<Post> findTimelinePosts(List<User> users, Pageable pageable);
        
        Page<Post> findByParentPostOrderByCreatedAtDesc(Post parentPost, Pageable pageable);
    }
    
    // LikeRepository.java
    package com.example.social.repository;
    
    import com.example.social.entity.Like;
    import com.example.social.entity.Post;
    import com.example.social.entity.User;
    import org.springframework.data.jpa.repository.JpaRepository;
    import org.springframework.stereotype.Repository;
    import java.util.Optional;
    
    @Repository
    public interface LikeRepository extends JpaRepository<Like, Long> {
        Optional<Like> findByUserAndPost(User user, Post post);
        boolean existsByUserAndPost(User user, Post post);
        void deleteByUserAndPost(User user, Post post);
    }
    

    Service Layer

    // UserService.java
    package com.example.social.service;
    
    import com.example.social.dto.UserCreateDto;
    import com.example.social.dto.UserResponseDto;
    import com.example.social.entity.User;
    import com.example.social.exception.ResourceNotFoundException;
    import com.example.social.exception.UsernameAlreadyExistsException;
    import com.example.social.repository.UserRepository;
    import lombok.RequiredArgsConstructor;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    @RequiredArgsConstructor
    @Transactional
    public class UserService {
        private final UserRepository userRepository;
        
        public UserResponseDto createUser(UserCreateDto dto) {
            if (userRepository.existsByUsername(dto.getUsername())) {
                throw new UsernameAlreadyExistsException("Username already taken");
            }
            if (userRepository.existsByEmail(dto.getEmail())) {
                throw new UsernameAlreadyExistsException("Email already registered");
            }
            
            User user = new User();
            user.setUsername(dto.getUsername());
            user.setEmail(dto.getEmail());
            user.setDisplayName(dto.getDisplayName());
            user.setBio(dto.getBio());
            
            User saved = userRepository.save(user);
            return mapToResponseDto(saved);
        }
        
        public UserResponseDto getUserById(Long id) {
            User user = userRepository.findById(id)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            return mapToResponseDto(user);
        }
        
        public UserResponseDto getUserByUsername(String username) {
            User user = userRepository.findByUsername(username)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            return mapToResponseDto(user);
        }
        
        public void followUser(Long userId, Long targetUserId) {
            if (userId.equals(targetUserId)) {
                throw new IllegalArgumentException("Cannot follow yourself");
            }
            
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            User targetUser = userRepository.findById(targetUserId)
                .orElseThrow(() -> new ResourceNotFoundException("Target user not found"));
            
            if (!targetUser.getFollowers().contains(user)) {
                targetUser.getFollowers().add(user);
                userRepository.save(targetUser);
            }
        }
        
        public void unfollowUser(Long userId, Long targetUserId) {
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            User targetUser = userRepository.findById(targetUserId)
                .orElseThrow(() -> new ResourceNotFoundException("Target user not found"));
            
            targetUser.getFollowers().remove(user);
            userRepository.save(targetUser);
        }
        
        private UserResponseDto mapToResponseDto(User user) {
            return UserResponseDto.builder()
                .id(user.getId())
                .username(user.getUsername())
                .displayName(user.getDisplayName())
                .bio(user.getBio())
                .followerCount(user.getFollowers().size())
                .followingCount(user.getFollowing().size())
                .postCount(user.getPosts().size())
                .createdAt(user.getCreatedAt())
                .build();
        }
    }
    
    // PostService.java
    package com.example.social.service;
    
    import com.example.social.dto.PostCreateDto;
    import com.example.social.dto.PostResponseDto;
    import com.example.social.entity.Post;
    import com.example.social.entity.User;
    import com.example.social.entity.Like;
    import com.example.social.exception.ResourceNotFoundException;
    import com.example.social.repository.PostRepository;
    import com.example.social.repository.UserRepository;
    import com.example.social.repository.LikeRepository;
    import lombok.RequiredArgsConstructor;
    import org.springframework.data.domain.Page;
    import org.springframework.data.domain.Pageable;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    
    @Service
    @RequiredArgsConstructor
    @Transactional
    public class PostService {
        private final PostRepository postRepository;
        private final UserRepository userRepository;
        private final LikeRepository likeRepository;
        
        public PostResponseDto createPost(Long userId, PostCreateDto dto) {
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            
            Post post = new Post();
            post.setContent(dto.getContent());
            post.setAuthor(user);
            
            if (dto.getParentPostId() != null) {
                Post parentPost = postRepository.findById(dto.getParentPostId())
                    .orElseThrow(() -> new ResourceNotFoundException("Parent post not found"));
                post.setParentPost(parentPost);
                parentPost.setReplyCount(parentPost.getReplyCount() + 1);
                postRepository.save(parentPost);
            }
            
            Post saved = postRepository.save(post);
            return mapToResponseDto(saved);
        }
        
        public Page<PostResponseDto> getUserPosts(Long userId, Pageable pageable) {
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            
            return postRepository.findByAuthorOrderByCreatedAtDesc(user, pageable)
                .map(this::mapToResponseDto);
        }
        
        public Page<PostResponseDto> getTimeline(Long userId, Pageable pageable) {
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            
            List<User> following = new ArrayList<>(user.getFollowing());
            following.add(user); // Include user's own posts
            
            return postRepository.findTimelinePosts(following, pageable)
                .map(this::mapToResponseDto);
        }
        
        public void likePost(Long userId, Long postId) {
            User user = userRepository.findById(userId)
                .orElseThrow(() -> new ResourceNotFoundException("User not found"));
            Post post = postRepository.findById(postId)
                .orElseThrow(() -> new ResourceNotFoundException("Post not found"));
            
            if (!likeRepository.existsByUserAndPost(user, post)) {
                Like like = new Like();
                like.setUser(user);
                like.setPost(post);
                likeRepository.save(like);
                
                post.setLikeCount(post.getLikeCount() + 1);
                postRepository.save(post);
            }
        }
        
        public void unlikePost(Long userId, Long postId) {
            User user = userRepository.findById(userId)
                .orElseThrow(()
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.