Single Responsibility Principle

// ❌ BAD: This class has MULTIPLE responsibilities!
public class UserManager {
    
    // Responsibility 1: User data management
    private String name;
    private String email;
    
    // Responsibility 2: Database operations
    public void saveToDatabase() {
        // Connect to database
        Connection conn = DriverManager.getConnection("jdbc:mysql://...");
        PreparedStatement stmt = conn.prepareStatement(
            "INSERT INTO users (name, email) VALUES (?, ?)"
        );
        stmt.setString(1, this.name);
        stmt.setString(2, this.email);
        stmt.executeUpdate();
        // If database changes (MySQL → PostgreSQL), this class changes!
    }
    
    // Responsibility 3: Email notifications
    public void sendWelcomeEmail() {
        // Set up email configuration
        Properties props = new Properties();
        props.put("mail.smtp.host", "smtp.gmail.com");
        Session session = Session.getInstance(props);
        Message msg = new MimeMessage(session);
        msg.setSubject("Welcome!");
        msg.setText("Hello " + this.name + ", welcome to our platform!");
        Transport.send(msg);
        // If email provider changes, this class changes!
    }
    
    // Responsibility 4: Input validation
    public boolean validateEmail() {
        return email != null && email.contains("@") && email.contains(".");
        // If validation rules change, this class changes!
    }
    
    // Responsibility 5: Password hashing
    public String hashPassword(String password) {
        return BCrypt.hashpw(password, BCrypt.gensalt());
        // If hashing algorithm changes, this class changes!
    }
    
    // Responsibility 6: Logging
    public void logUserActivity(String activity) {
        System.out.println(LocalDateTime.now() + ": " + name + " - " + activity);
        // If logging format changes, this class changes!
    }
}

/*
 * PROBLEMS:
 * 1. This class has 6 different reasons to change!
 * 2. Any team (DB, Email, Security, Logging) might modify it
 * 3. Hard to test - need to mock DB, email server, etc.
 * 4. Changes ripple through the entire class
 * 5. Violates separation of concerns
 */

// ✅ GOOD: Each class has ONE responsibility

// 1. User - Only holds user data (Data Transfer Object)
public class User {
    private final String name;
    private final String email;
    private final String passwordHash;

    public User(String name, String email, String passwordHash) {
        this.name = name;
        this.email = email;
        this.passwordHash = passwordHash;
    }

    // Only getters - just data, no behavior
    public String getName() { return name; }
    public String getEmail() { return email; }
    public String getPasswordHash() { return passwordHash; }
}

// 2. UserValidator - Only validates user input
public class UserValidator {
    public boolean isValidEmail(String email) {
        return email != null && 
               email.contains("@") && 
               email.contains(".") &&
               email.length() > 5;
    }

    public boolean isValidPassword(String password) {
        return password != null && password.length() >= 8;
    }

    public boolean isValidName(String name) {
        return name != null && !name.trim().isEmpty();
    }
}

// 3. PasswordHasher - Only hashes passwords
public class PasswordHasher {
    public String hash(String password) {
        return BCrypt.hashpw(password, BCrypt.gensalt());
    }

    public boolean verify(String password, String hash) {
        return BCrypt.checkpw(password, hash);
    }
}

// 4. UserRepository - Only handles database operations
public class UserRepository {
    private final DataSource dataSource;

    public UserRepository(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public void save(User user) {
        try (Connection conn = dataSource.getConnection()) {
            PreparedStatement stmt = conn.prepareStatement(
                "INSERT INTO users (name, email, password_hash) VALUES (?, ?, ?)"
            );
            stmt.setString(1, user.getName());
            stmt.setString(2, user.getEmail());
            stmt.setString(3, user.getPasswordHash());
            stmt.executeUpdate();
        }
    }

    public User findByEmail(String email) {
        // Query database and return User
    }
}

// 5. EmailService - Only sends emails
public class EmailService {
    private final String smtpHost;
    private final String fromAddress;

    public EmailService(String smtpHost, String fromAddress) {
        this.smtpHost = smtpHost;
        this.fromAddress = fromAddress;
    }

    public void sendWelcomeEmail(User user) {
        String subject = "Welcome!";
        String body = "Hello " + user.getName() + ", welcome to our platform!";
        sendEmail(user.getEmail(), subject, body);
    }

    private void sendEmail(String to, String subject, String body) {
        // Email sending logic
    }
}

// 6. ActivityLogger - Only logs activities
public class ActivityLogger {
    public void log(User user, String activity) {
        System.out.println(
            LocalDateTime.now() + " [" + user.getEmail() + "] " + activity
        );
    }
}

// 7. UserService - Orchestrates the workflow (Facade)
public class UserService {
    private final UserValidator validator;
    private final PasswordHasher hasher;
    private final UserRepository repository;
    private final EmailService emailService;
    private final ActivityLogger logger;

    public UserService(UserValidator validator, PasswordHasher hasher,
                       UserRepository repository, EmailService emailService,
                       ActivityLogger logger) {
        this.validator = validator;
        this.hasher = hasher;
        this.repository = repository;
        this.emailService = emailService;
        this.logger = logger;
    }

    public User registerUser(String name, String email, String password) {
        // Validate
        if (!validator.isValidEmail(email)) {
            throw new IllegalArgumentException("Invalid email");
        }
        if (!validator.isValidPassword(password)) {
            throw new IllegalArgumentException("Invalid password");
        }

        // Create user with hashed password
        String hash = hasher.hash(password);
        User user = new User(name, email, hash);

        // Save to database
        repository.save(user);

        // Send welcome email
        emailService.sendWelcomeEmail(user);

        // Log activity
        logger.log(user, "User registered");

        return user;
    }
}