Cum Scriem Codul | Filosofie Tehnică | Tech Sculptors Năsăud

Single Responsibility Principle

Controller-ul nu face business logic

Un controller are o singură responsabilitate: să primească requestul, să îl delege serviciului și să returneze răspunsul. Nimic mai mult. Dacă un controller face calcule sau accesează direct baza de date — e o problemă de arhitectură.

Spring BootREST ControllerClean Code

ProjectController.java

Java 21

@RestController
@RequestMapping("/api/v1/projects")
@RequiredArgsConstructor
@Validated
public class ProjectController {

  // Constructor injection — nu @Autowired pe field
  private final ProjectService projectService;

  @GetMapping("/published")
  public ResponseEntity<List<ProjectDto>> getPublished() {
    // Controller nu știe cum se obțin proiectele
    return ResponseEntity.ok(projectService.getPublished());
  }

  @PostMapping
  @PreAuthorize("hasRole('ADMIN')")
  public ResponseEntity<ProjectDto> create(
      @Valid @RequestBody CreateProjectRequest req) {

    ProjectDto created = projectService.create(req);
    URI location = URI.create("/api/v1/projects/" + created.getId());
    // 201 Created cu Location header — REST corect
    return ResponseEntity.created(location).body(created);
  }
}

💡

Constructor injection face clasa testabilă fără Spring context și dependențele explicite, nu ascunse în câmpuri private.

Fail Fast + Defensive Programming

Serviciul validează, transformă, orchestrează

Business logic stă exclusiv în Service layer. Validăm la intrare, transformăm datele, orchestrăm mai multe repository-uri dacă e nevoie. Erorile sunt specifice și explicite — niciodată NullPointerException sau mesaje generice.

Service LayerException HandlingDTO Pattern

ProjectService.java

Java 21

@Service
@RequiredArgsConstructor
@Transactional(readOnly = true) // read-only implicit
public class ProjectService {

  private final ProjectRepository projectRepository;
  private final ProjectMapper     projectMapper;
  private final SlugUtil          slugUtil;

  public List<ProjectDto> getPublished() {
    return projectRepository
      .findByStatusOrderBySortOrderAsc(PublishStatus.PUBLISHED)
      .stream()
      .map(projectMapper::toDto) // Entity → DTO
      .toList();
  }

  @Transactional // write — override read-only
  public ProjectDto create(CreateProjectRequest req) {
    var slug = req.getSlug() != null
      ? req.getSlug()
      : slugUtil.toSlug(req.getTitle());

    // Fail fast — verificăm unicitatea înainte
    if (projectRepository.existsBySlug(slug)) {
      throw new DuplicateSlugException(slug);
    }
    var p = projectMapper.toEntity(req);
    p.setSlug(slug);
    return projectMapper.toDto(projectRepository.save(p));
  }
}

💡

@Transactional(readOnly = true) la nivel de clasă reduce lock-urile pe DB și permite optimizări Hibernate. Scrierile îl suprascriu explicit.

Query Optimization + Type Safety

Repository cu query-uri clare, nu magic strings

JPQL în loc de query-uri native oriunde e posibil — portabil între baze de date. Projection interfaces pentru query-uri read-only — selectăm doar coloanele necesare. Paginare încorporată pentru liste mari.

Spring Data JPAJPQLProjection

ProjectRepository.java

Java 21 + JPA

public interface ProjectRepository
    extends JpaRepository<Project, Long> {

  // Named query — SQL optim generat automat
  List<Project> findByStatusOrderBySortOrderAsc(
    PublishStatus status
  );

  // Projection — doar title + slug, fără tot obiectul
  @Query("SELECT p.title as title, p.slug as slug " +
         "FROM Project p WHERE p.status = :status")
  List<ProjectSummary> findSummariesByStatus(
    @Param("status") PublishStatus status
  );

  // Paginare în semnătura metodei
  Page<Project> findByClientSector(
    String sector, Pageable pageable
  );

  // SELECT 1, nu SELECT * — eficient
  boolean existsBySlug(String slug);
}

// Interface-based projection — type-safe
public interface ProjectSummary {
  String getTitle();
  String getSlug();
}

💡

Projection interfaces reduc traficul DB cu 60-80% pe listing-uri. Hibernate selectează doar coloanele din interfață, nu întreaga entitate cu toate relațiile.

Defense in Depth

Securitate în straturi, nu un singur punct de control

Nu ne bazăm pe un singur mecanism. Rate limiting la nivel de IP, JWT la nivel de request, Spring Security la nivel de URL, și @PreAuthorize la nivel de metodă. Un atacator trebuie să treacă prin toate.

Spring Security 6JWT HS512Bucket4j

SecurityConfig.java

Spring Security 6

// Strat 1: Rate limiting Bucket4j per IP
// /admin/login → 10 încercări / 30 min
// /contact POST → 5 mesaje / 10 min

@Bean
public SecurityFilterChain filterChain(HttpSecurity http) {
  http
    .authorizeHttpRequests(auth -> auth
      .requestMatchers("/css/**", "/js/**").permitAll()
      // Setări — doar SUPER_ADMIN
      .requestMatchers("/admin/setari").hasRole("SUPER_ADMIN")
      .requestMatchers("/admin/**")
        .hasAnyRole("ADMIN", "SUPER_ADMIN")
    )
    .headers(h -> h
      .contentSecurityPolicy(csp -> csp.policyDirectives(policy))
      .frameOptions(f -> f.deny()) // Anti-clickjacking
    );

  // Strat 2: JWT HS512, access token 15 min
  http.addFilterBefore(rateLimitFilter, JwtFilter.class);
  http.addFilterBefore(jwtFilter, UsernamePasswordFilter.class);
  return http.build();
}

// Strat 3: BCrypt strength 12 — ~250ms/hash
@Bean
public PasswordEncoder passwordEncoder() {
  return new BCryptPasswordEncoder(12);
}

💡

BCrypt strength 12 = 4096 runde de hashing. Un atac brute-force cu 1 milion de parole ar dura mii de ani pe hardware modern.

COD curat. ÎNTOTDEAUNA.

Controller-ul nu face business logic

Serviciul validează, transformă, orchestrează

Repository cu query-uri clare, nu magic strings

Securitate în straturi, nu un singur punct de control