Spring Boot আর Rails — enterprise Java আর convention over configuration

১ · দুই দর্শন — সব লিখে দেওয়া, নাকি নিয়ম মেনে চলা

দুটি রেস্তোরাঁর কথা ভাবুন। একটি বড় হোটেল চেইনের রান্নাঘর। সেখানে প্রতিটি পদের লিখিত নিয়ম আছে, কে কোন চুলায় দাঁড়াবেন তার তালিকা আছে, আর সব কিছু খাতায় সই করে হয়। নতুন কেউ এলে খাতা পড়ে কাজ বোঝেন। আরেকটি পাড়ার পুরোনো হোটেল। সেখানে লেখা কিছু নেই, কিন্তু সবাই জানেন লবণ বাঁ দিকের তাকে, ডাল সবসময় তিন নম্বর হাঁড়িতে। নিয়ম মানলে কিছু বলতেই হয় না। নিয়ম না জানলে নতুন মানুষ প্রথম দিন হারিয়ে যান।

প্রথমটি Spring Boot-এর দর্শন: Java-র কঠোর type, স্পষ্ট annotation আর একটি container, যা সব অংশ জোড়া লাগায়। দ্বিতীয়টি Ruby on Rails-এর convention over configuration: Product নামের model থাকলে টেবিল products, controller ProductsController, আর কাউকে তা বলে দিতে হয় না। পর্ব ৪-এ (Architecture pattern) দেখা MVC দুটিরই কঙ্কাল।

দুই framework-ই বাজারঘরের একই টুকরো বানিয়েছে: ৩টি ক্যাটাগরি, ৬টি পণ্য, স্টকে থাকা পণ্যের তালিকা দামের ক্রমে, একটি পণ্য দেখা, আর যাচাইসহ নতুন পণ্য যোগ। Laravel, Django আর FastAPI-র lab-এও একই fixture, তাই শেষে তুলনা ন্যায্য হবে। নিচের ছবিতে একটি request দুই stack-এ কোন কোন স্তর পেরোয়।

২ · Spring Boot শুরু — starter, auto-configuration আর একটি jar

Spring Boot project সাধারণত start.spring.io (Spring Initializr) থেকে শুরু হয়। আপনি dependency বেছে নেন, সে একটি zip দেয়। ভেতরের সবচেয়ে গুরুত্বপূর্ণ ফাইল Maven-এর pom.xml. Maven আর Gradle-এর বিস্তারিত আছে Java কোর্সের Maven পর্বে.

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>4.1.2</version>
</parent>
<properties><java.version>25</java.version></properties>
<dependencies>
  <dependency><artifactId>spring-boot-starter-webmvc</artifactId></dependency>
  <dependency><artifactId>spring-boot-starter-data-jpa</artifactId></dependency>
  <dependency><artifactId>spring-boot-starter-validation</artifactId></dependency>
  <dependency><artifactId>h2</artifactId><scope>runtime</scope></dependency>
</dependencies>

এখানে দুটি ধারণা। Starter হলো একটি “ঝুড়ি” dependency: starter-data-jpa লিখলে Hibernate, connection pool, Spring Data সব একসাথে আসে, আর তাদের version পরস্পরের সাথে মেলানো থাকে। Parent POM সেই version-গুলোর তালিকা রাখে, তাই ওপরে কোনো dependency-তে version লেখা নেই। লক্ষ করুন, web-এর starter-টির নাম spring-boot-starter-webmvc. Spring Boot 4-এ Initializr এই নাম দিয়েছে। Boot 3-এর লেখা ও টিউটোরিয়ালে আপনি spring-boot-starter-web দেখবেন, তাই কোন সংস্করণের docs পড়ছেন মিলিয়ে নিন।

প্রথম ফাঁদ: .RELEASE

Initializr-এর metadata-তে version লেখা ছিল 4.1.2.RELEASE. পুরোনো Spring Boot সংস্করণে (২.৩ পর্যন্ত; ২.৪ থেকে নেই) সত্যিই এমন নাম ছিল, তাই অনেক পুরোনো উদাহরণে এটি দেখা যায়। কিন্তু Maven-এর ভাণ্ডারে এখনকার parent-এর নাম শুধু 4.1.2. ভুল নামটি দিলে কী হয়, আমরা ইচ্ছা করে চালিয়ে দেখলাম:

সত্যিকারের run · Maven 3.10.0 · parent-এ 4.1.2.RELEASE · আউটপুট ছাঁটা

$ mvn -U validate
Downloading from central: …/spring-boot-starter-parent/4.1.2.RELEASE/spring-boot-starter-parent-4.1.2.RELEASE.pom
[ERROR] [ERROR] Some problems were encountered while processing the POMs:
[FATAL] Non-resolvable parent POM for com.bazarghar:bazarghar:0.0.1-SNAPSHOT: The following artifacts could not be resolved: org.springframework.boot:spring-boot-starter-parent:pom:4.1.2.RELEASE (absent): Could not find artifact … in central (https://repo.maven.apache.org/maven2) and 'parent.relativePath' points at no local POM @ line 5, column 10

বার্তাটি লম্বা, কিন্তু মূল কথা “absent”: এই নামের ফাইল ভাণ্ডারে নেই। Version থেকে .RELEASE মুছলেই build চলে। Error পড়ার এই অভ্যাস, অর্থাৎ প্রথম FATAL লাইনে কোন artifact আর কেন, খুঁজে নেওয়া, Java জগতে প্রতিদিন কাজে লাগে।

Auto-configuration: “classpath-এ কী আছে, দেখে সাজাও”

আমাদের কোডে কোথাও লেখা নেই “Tomcat চালাও” বা “H2-তে connection pool বানাও”। তবু দুটিই হয়। এর নাম auto-configuration. Spring Boot অনেকগুলো configuration class নিয়ে আসে, প্রতিটির গায়ে শর্ত লেখা: “এই class classpath-এ থাকলে”, “আপনি নিজে এই bean না বানালে”, “এই property থাকলে”। শর্ত মিললে সেটি চালু হয়। --debug দিয়ে চালালে Boot একটি রিপোর্ট ছাপে, কোনটি কেন মিলল আর কোনটি কেন মিলল না। নিচের stepper সেই রিপোর্ট আর startup log থেকে বানানো।

@SpringBootApplication
public class BazargharApplication {
  public static void main(String[] args) {
    SpringApplication.run(BazargharApplication.class, args);
  }
}

01:10:50.660 Starting BazargharApplication v0.0.1-SNAPSHOT using Java 25.0.5
01:10:51.125 Bootstrapping Spring Data JPA repositories in DEFAULT mode.
01:10:51.160 Finished Spring Data repository scanning in 28 ms.
             Found 2 JPA repository interfaces.

CONDITIONS EVALUATION REPORT
Positive matches:
   DataSourceAutoConfiguration matched:
      - @ConditionalOnClass found required classes 'javax.sql.DataSource', …
      - @ConditionalOnMissingBean (types: io.r2dbc.spi.ConnectionFactory; …) did not find any beans
Negative matches:
   H2ConsoleAutoConfiguration:
      Did not match:
         - @ConditionalOnBooleanProperty (spring.h2.console.enabled=true) did not find property …

DataSourceConfiguration.Hikari matched:
   - @ConditionalOnClass found required class 'com.zaxxer.hikari.HikariDataSource'
DataSourceConfiguration.Tomcat:
   Did not match:
   - @ConditionalOnClass did not find required class 'org.apache.tomcat.jdbc.pool.DataSource'
01:10:51.822 HikariPool-1 - Added connection conn0: url=jdbc:h2:mem:bazarghar

HibernateJpaConfiguration matched:
   - @ConditionalOnSingleCandidate (types: javax.sql.DataSource) found a single bean 'dataSource'
01:10:51.885 HHH000001: Hibernate ORM core version 7.4.13.Final
01:10:52.747 Initialized JPA EntityManagerFactory for persistence unit 'default'

01:10:51.541 Starting Servlet engine: [Apache Tomcat/11.0.27]
01:10:53.434 Tomcat started on port 8126 (http) with context path '/'
01:10:53.443 Started BazargharApplication in 3.077 seconds
             (process running for 3.396)

একটি jar, তার ওজন আর চালু হওয়ার সময়

mvn package একটি fat jar বানায়: আপনার class আর সব dependency এক ফাইলে। java -jar দিলেই চলে, তাই container image বানানোও সহজ (Docker Compose পর্ব দেখুন)।

সত্যিকারের run · একটি local কম্পিউটারে · ২০২৬-১১-০১ আর ২০২৬-১১-০৩ · সাধারণ ফল নয়

অর্থাৎ jar-এর প্রায় ০.০৪% আমাদের কোড, বাকিটা framework. তুলনায় পর্ব ২৪-এর (Node.js server) একটি সাধারণ Node server প্রায় তৎক্ষণাৎ চালু হয়। ২–৩ সেকেন্ড দিনে একবার চালু হওয়া server-এর জন্য কিছুই না। কিন্তু যেখানে প্রতিটি request-এ নতুন করে চালু হতে হয় (serverless-এর cold start), সেখানে এটি গুরুত্বপূর্ণ। এই কারণে Java জগতে GraalVM native image আর CDS-এর মতো কৌশল আছে, যা এই পর্বে আমরা চালাইনি।

৩ · Controller, constructor injection আর IoC container

এবার বাজারঘরের API. Java-র ভাষা আর record জানতে Java কোর্সের Spring REST পর্ব দেখুন। এখানে আমরা নকশায় মন দেব।

@RestController
@RequestMapping("/api/products")
public class ProductController {
    private final ProductRepository products;
    private final CategoryRepository categories;

    public ProductController(ProductRepository products, CategoryRepository categories) {
        this.products = products;          // কেউ new করে দেবে, আমরা নই
        this.categories = categories;
    }

    @GetMapping
    public List<ProductView> list() {
        return products.findByStockGreaterThanOrderByPrice(0).stream().map(ProductView::of).toList();
    }

    @GetMapping("/{id}")
    public ProductView get(@PathVariable Long id) {
        return products.findWithCategoryById(id).map(ProductView::of)
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.NOT_FOUND));
    }

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public ProductView create(@Valid @RequestBody ProductRequest body) {
        Category category = categories.findById(body.categoryId())
                .orElseThrow(() -> new ResponseStatusException(HttpStatus.UNPROCESSABLE_CONTENT, "unknown category"));
        return ProductView.of(products.save(new Product(category, body.name(), body.price(), body.stock())));
    }
}

@RestController বলে “এই class-এর method-এর ফল JSON হয়ে যাবে”। @GetMapping("/{id}") URL আর method জোড়ে, Express-এর router.get('/:id', …)-এর মতো (পর্ব ২৫)। লক্ষ করুন, controller entity সরাসরি ফেরত দেয় না, ছোট একটি ProductView record দেয়। এতে ক্লায়েন্ট কোন ঘর দেখবে তা আমরা ঠিক করি, আর Hibernate-এর অর্ধেক লোড হওয়া object JSON-এ যাওয়ার ঝুঁকি থাকে না।

সবচেয়ে গুরুত্বপূর্ণ লাইন constructor. Controller নিজে repository বানায় না, চায়। কে দেয়? Spring-এর IoC container. পর্ব ২৯-এ (Backend-এর গঠন) আমরা compose.ts-এ হাতে dependency injection করেছিলাম, আর বলেছিলাম object অনেক হলে container লাগে। Spring ঠিক সেই container. একে inversion of control বলে, কারণ object বানানোর নিয়ন্ত্রণ আপনার হাত থেকে framework-এর হাতে যায়। Constructor-এ চাওয়াই এখনকার পরামর্শ: field final রাখা যায়, আর test-এ নকল repository হাতে দিয়ে new ProductController(…) লেখা যায়।

Container ভেতরে কী করে? Constructor-এর parameter-এর type পড়ে, আগে সেগুলো বানায়, তারপর নিজেকে। আর একবার বানানো object মনে রাখে, ফলে পুরো অ্যাপে প্রতিটি bean সাধারণত একটিই , যাকে বলে singleton. নিচে reflection দিয়ে ৩০ লাইনের একটি শেখানোর মডেল, আসল Spring নয়:

import java.lang.reflect.Constructor;
import java.util.*;
class Db { }
class ProductRepository { final Db db; ProductRepository(Db db) { this.db = db; } }
class CategoryRepository { final Db db; CategoryRepository(Db db) { this.db = db; } }
class ProductController { ProductController(ProductRepository p, CategoryRepository c) { } }
class Container {
    private final Map<Class<?>, Object> beans = new LinkedHashMap<>();
    private int depth = 0;
    <T> T get(Class<T> type) throws Exception {
        String pad = "  ".repeat(depth);
        if (beans.containsKey(type)) { System.out.println(pad + "reuse  " + type.getSimpleName()); return type.cast(beans.get(type)); }
        Constructor<?> ctor = type.getDeclaredConstructors()[0];
        Class<?>[] needs = ctor.getParameterTypes();
        System.out.println(pad + "need   " + type.getSimpleName() + " (" + needs.length + " args)");
        Object[] args = new Object[needs.length];
        depth++;
        for (int i = 0; i < needs.length; i++) args[i] = get(needs[i]);
        depth--;
        Object bean = ctor.newInstance(args);
        beans.put(type, bean);
        System.out.println(pad + "create " + type.getSimpleName());
        return type.cast(bean);
    }
    int size() { return beans.size(); }
}
class Main {
    public static void main(String[] args) throws Exception {
        Container c = new Container();
        c.get(ProductController.class);
        System.out.println("beans: " + c.size() + ", same Db? " + (c.get(ProductRepository.class).db == c.get(CategoryRepository.class).db));
    }
}

৪ · Spring Data JPA, Hibernate আর N+1

Java-য় ডেটাবেসের মান হলো JPA (Jakarta Persistence): annotation আর interface-এর একটি নিয়মপত্র। সেটি বাস্তবায়ন করে Hibernate, যা SQL বানায়। আর Spring Data JPA তার ওপর repository দেয়। পর্ব ৩৮-এর (ORM-এর ধারণা) ভাষায় Hibernate একটি data mapper: entity class সাধারণ Java object, নিজে নিজেকে save করে না।

@Entity
public class Product {
    @Id @GeneratedValue
    private Long id;
    private String name;
    private int price;
    private int stock;
    @ManyToOne(fetch = FetchType.LAZY, optional = false)
    private Category category;     // টেবিলে category_id কলাম

    protected Product() { }        // JPA-র জন্য খালি constructor
}

public interface ProductRepository extends JpaRepository<Product, Long> {
    @EntityGraph(attributePaths = "category")
    List<Product> findByStockGreaterThanOrderByPrice(int stock);

    @EntityGraph(attributePaths = "category")
    Optional<Product> findWithCategoryById(Long id);

    @Query("select p from Product p join fetch p.category order by p.price")
    List<Product> findAllWithCategory();
}

Repository-তে কোনো method body নেই! findByStockGreaterThanOrderByPrice নামটি পড়েই Spring Data query বানায়: where stock > ? order by price. এটিও এক ধরনের convention, Rails-এর মতোই। আর JpaRepository থেকে findAll, findById, save বিনা খরচে আসে। Spring Data-র বিস্তারিত আছে Java কোর্সের Spring Data JPA পর্বে.

N+1: আমাদের run-এ ৭ নয়, ৪

পর্ব ৪২-এ (N+1 সমস্যা) Prisma-য় লুপটি হাতে লিখতে হতো। Hibernate-এ lazy loading আছে: p.getCategory().getName() লিখলেই গোপনে SQL যায়। একটি transaction-এর ভেতরে তিনটি পথ মাপা হলো, Hibernate-এর statistics দিয়ে SQL গুনে:

count("Lazy loading", () -> products.findAll().forEach(p -> p.getCategory().getName()));
count("@EntityGraph", () -> products.findByStockGreaterThanOrderByPrice(-1).forEach(p -> p.getCategory().getName()));
count("join fetch",   () -> products.findAllWithCategory().forEach(p -> p.getCategory().getName()));

সত্যিকারের run · Hibernate 7.4.13 · H2 · ৩টি ক্যাটাগরি, ৬টি পণ্য · spring.jpa.show-sql=true · ছাঁটা

Hibernate: select p1_0.id,p1_0.category_id,p1_0.name,p1_0.price,p1_0.stock from product p1_0
Hibernate: select c1_0.id,c1_0.name from category c1_0 where c1_0.id=?
Hibernate: select c1_0.id,c1_0.name from category c1_0 where c1_0.id=?
Hibernate: select c1_0.id,c1_0.name from category c1_0 where c1_0.id=?
Lazy loading: 4 queries
Hibernate: select p1_0.id,p1_0.category_id,c1_0.id,c1_0.name,p1_0.name,p1_0.price,p1_0.stock from product p1_0 join category c1_0 on c1_0.id=p1_0.category_id where p1_0.stock>? order by p1_0.price
@EntityGraph: 1 queries
Hibernate: select … from product p1_0 join category c1_0 on c1_0.id=p1_0.category_id order by p1_0.price
join fetch: 1 queries

৬টি পণ্যে ১ + ৬ = ৭ আশা করেছিলেন? এসেছে ৪. কারণ Hibernate-এর persistence context. একটি transaction-এর ভেতরে একই id-র ক্যাটাগরি একবার আনা হলে পরেরবার মেমরি থেকে দেয়। এটি একটি identity map. তাই সংখ্যাটি ১ + (আলাদা ক্যাটাগরির সংখ্যা) = ১ + ৩. সান্ত্বনা পাবেন না: ১,০০০ পণ্য ২০০ ক্যাটাগরিতে ছড়ানো থাকলে ২০১টি SQL, আর প্রতিটি পণ্যের আলাদা বিক্রেতা থাকলে আবার পুরো ১ + N.

@EntityGraph বলে “এই query-তে category-ও আনুন”, আর Hibernate একটি JOIN লেখে। optional = false থাকায় এটি inner join; ক্যাটাগরি ঐচ্ছিক হলে left join হতো। join fetch একই কাজ JPQL-এ হাতে লেখা। দুটিই ১টি SQL.

৫ · Validation — ডিফল্ট 400 থেকে মাঠভিত্তিক 422

Spring-এ ইনপুটের নিয়ম লেখা হয় Bean Validation-এর annotation দিয়ে, request-এর record-এর গায়ে। Controller-এ @Valid লিখলে Spring body পড়ার পরে নিয়মগুলো যাচাই করে।

public record ProductRequest(
        @NotNull Long categoryId,
        @NotBlank String name,
        @Min(1) int price,
        @Min(0) int stock) { }

এবার একটি ভুল body পাঠানো হলো: নাম ফাঁকা, দাম ০. কোনো বাড়তি কোড ছাড়া Spring যা ফেরত দিল:

সত্যিকারের run · Spring Boot 4.1.2 · ডিফল্ট setting · 127.0.0.1

$ POST /api/products  {"categoryId":2,"name":"","price":0,"stock":1}
{"timestamp":"2026-11-02T19:11:03.725Z","status":400,"error":"Bad Request","path":"/api/products"}
HTTP 400 application/json

এই উত্তরে কোন ঘরে সমস্যা, তা নেই। React-এর form কোন input-এর নিচে লাল লেখা দেখাবে, জানবে না। Laravel, FastAPI আর Rails-এর lab-এ একই ভুল body 422 আর ঘরভিত্তিক বার্তা পেয়েছিল। পর্ব ৩৩-এর (Status code আর error format) নিয়মে: body পড়া গেছে কিন্তু নিয়ম ভেঙেছে, তাই 422. দুই ধাপে ঠিক করা যায়।

ধাপ ১, spring.mvc.problemdetails.enabled=true. এতে error-এর আকৃতি RFC 9457-এর problem details হয়, কিন্তু status আর বিস্তারিত বদলায় না:

সত্যিকারের run · একই body · property চালু

{"detail":"Invalid request content.","instance":"/api/products","status":400,"title":"Bad Request"}
HTTP 400 application/problem+json

ধাপ ২, একটি ছোট @RestControllerAdvice, যা validation-এর exception ধরে নিজের ProblemDetail বানায়:

@RestControllerAdvice
public class ValidationErrors {
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ProblemDetail invalid(MethodArgumentNotValidException ex) {
        ProblemDetail problem = ProblemDetail.forStatusAndDetail(
                HttpStatus.UNPROCESSABLE_CONTENT, "The product has invalid fields.");
        Map<String, String> errors = new TreeMap<>();
        ex.getBindingResult().getFieldErrors()
          .forEach(e -> errors.put(e.getField(), e.getDefaultMessage()));
        problem.setProperty("errors", errors);
        return problem;
    }
}

সত্যিকারের run · advice যোগ করার পরে · একই body

{"detail":"The product has invalid fields.","instance":"/api/products","status":422,"title":"Unprocessable Content",
 "errors":{"name":"must not be blank","price":"must be greater than or equal to 1"}}
HTTP 422 application/problem+json

এখন ক্লায়েন্ট errors.name পড়ে ঠিক ঘরে বার্তা দেখাতে পারে। HttpStatus.UNPROCESSABLE_CONTENT নামটি HTTP-র এখনকার মান RFC 9110-এর শব্দ; পুরোনো কোডে UNPROCESSABLE_ENTITY দেখবেন। Annotation পড়ে যাচাই কীভাবে হয়, নিচে reflection দিয়ে একটি শেখানোর মডেল:

import java.lang.annotation.*;
import java.lang.reflect.RecordComponent;
import java.util.*;

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.RECORD_COMPONENT) @interface NotBlank { }
@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.RECORD_COMPONENT) @interface Min { int value(); }

record ProductRequest(@NotBlank String name, @Min(1) int price, @Min(0) int stock) { }

class Validator {
    static Map<String, String> check(Object body) throws Exception {
        Map<String, String> errors = new TreeMap<>();
        for (RecordComponent rc : body.getClass().getRecordComponents()) {
            Object value = rc.getAccessor().invoke(body);
            if (rc.isAnnotationPresent(NotBlank.class) && (value == null || value.toString().isBlank()))
                errors.put(rc.getName(), "must not be blank");
            Min min = rc.getAnnotation(Min.class);
            if (min != null && (Integer) value < min.value())
                errors.put(rc.getName(), "must be greater than or equal to " + min.value());
        }
        return errors;
    }
}
class Main {
    public static void main(String[] args) throws Exception {
        List<ProductRequest> bodies = List.of(
            new ProductRequest("Darjeeling Tea", 350, 4),
            new ProductRequest("   ", 0, -2));
        for (ProductRequest body : bodies) {
            Map<String, String> errors = Validator.check(body);
            if (errors.isEmpty()) System.out.println("201 " + body);
            else System.out.println("422 " + errors);
        }
    }
}

দুটি ছোট নোট: virtual thread আর Spring Security

Virtual thread. Spring MVC প্রতিটি request-কে একটি thread দেয়। ডেটাবেসের উত্তরের অপেক্ষায় সেই thread বসে থাকে, আর সাধারণ OS thread দামি, তাই একটি thread pool-এ সীমিত। Java 21 থেকে virtual thread স্থায়ী বৈশিষ্ট্য: খুব হালকা thread, অপেক্ষার সময় আসল OS thread ছেড়ে দেয়। Spring Boot-এর docs অনুযায়ী spring.threads.virtual.enabled=true দিলেই চালু হয় (Java 21 লাগে, docs Java 24 বা পরের সংস্করণ জোর দিয়ে সুপারিশ করে)। আমরা একটি endpoint দিয়ে যাচাই করলাম, যে Thread.currentThread() ফেরত দেয়:

সত্যিকারের run · JDK 25.0.5 · দুবার চালানো, setting ছাড়া আর setting সহ

$ curl -s /api/products/thread
Thread[#69,http-nio-127.0.0.1-8126-exec-8,5,main]                       # ডিফল্ট: pool-এর thread
$ curl -s /api/products/thread        # --spring.threads.virtual.enabled=true
VirtualThread[#74,tomcat-handler-5]/runnable@ForkJoinPool-1-worker-1

এটি Node.js-এর event loop-এর মতো সুবিধা দেয়, কিন্তু কোড থাকে সাধারণ blocking ধাঁচে, async ছাড়াই। তবে docs নিজেই সতর্ক করে: “pinned” virtual thread-এ throughput কমতে পারে, আর thread pool-এর setting তখন আর খাটে না। লোড test ছাড়া এটি চালু করে দ্রুত হবে ভাববেন না। ভেতরের কাজ জানতে Java কোর্সের virtual thread পর্ব দেখুন।

Spring Security. Login, role আর CSRF সামলায় এই আলাদা project. Docs অনুযায়ী starter যোগ করলেই সব endpoint ডিফল্টে লগইন চায়, যা নিরাপদ শুরু। আমরা এই lab-এ এটি চালাইনি। ধারণাগুলো পর্ব ৪৫–৪৮-এ, Spring-এর কোড Java কোর্সের Spring Security পর্বে, আর তত্ত্ব Cybersecurity কোর্সে.

৬ · Rails — generator, migration আর নামের নিয়ম

এবার পাড়ার পুরোনো হোটেল। Rails লেখা হয় Ruby-তে। সাইটে Ruby কোর্স নেই, তাই কোড পড়ার মতো সামান্যটুকু:

Rails-এ কাজ শুরু হয় generator দিয়ে। এক লাইনে model, migration, test আর fixture ফাইল তৈরি:

সত্যিকারের run · Rails 8.1.4 · Ruby 4.0.9 · rails new bazarghar --minimal --api থেকে · ~/bazarghar

$ rails generate model Product category:references name:string price:integer stock:integer
      invoke  active_record
      create    db/migrate/20261031202016_create_products.rb
      create    app/models/product.rb
      invoke    test_unit
      create      test/models/product_test.rb
      create      test/fixtures/products.yml

$ rails db:migrate
== 20261031202016 CreateProducts: migrating ===================================
-- create_table(:products)
   -> 0.0062s
== 20261031202016 CreateProducts: migrated (0.0062s) ==========================

class CreateProducts < ActiveRecord::Migration[8.1]
  def change
    create_table :products do |t|
      t.references :category, null: false, foreign_key: true
      t.string :name
      t.integer :price
      t.integer :stock
      t.timestamps
    end
  end
end

কোথাও লেখা নেই টেবিলের নাম products হবে, বা category_id কলাম categories টেবিলকে নির্দেশ করবে। নাম থেকেই Rails বোঝে। t.references index আর foreign key দুটিই দিয়েছে। পর্ব ৪২-এ দেখেছিলেন, PostgreSQL-এ Prisma-র migration foreign key-তে নিজে index দেয়নি; Rails-এর schema.rb-এ এখানে index_products_on_category_id আছে। Migration-এর সাধারণ নিয়ম পর্ব ৪০-এ (Migration আর seed) পাবেন।

Rails-এর নামের নিয়ম কেমন, নিচে Python-এ একটি ছোট শেখানোর মডেল. আসল Rails-এর ActiveSupport::Inflector অনেক বেশি নিয়ম জানে।

# শেখানোর মডেল: Rails-এর নামের convention, খুব ছোট করে
import re

IRREGULAR = {"person": "people", "child": "children"}

def snake(name):                       # OrderItem -> order_item
    return re.sub(r"(?<!^)([A-Z])", r"_\1", name).lower()

def plural(word):                      # category -> categories
    if word in IRREGULAR:
        return IRREGULAR[word]
    if re.search(r"[^aeiou]y$", word):
        return word[:-1] + "ies"
    if re.search(r"(s|x|z|ch|sh)$", word):
        return word + "es"
    return word + "s"

def conventions(model):
    one = snake(model)
    many = "_".join(one.split("_")[:-1] + [plural(one.split("_")[-1])])
    camel = "".join(part.capitalize() for part in many.split("_"))
    return {
        "table": many,
        "file": f"app/models/{one}.rb",
        "controller": f"{camel}Controller",
        "foreign key": f"{one}_id",
        "routes": f"/{many}  /{many}/:id",
    }

for model in ["Product", "Category", "OrderItem", "Box", "Person"]:
    c = conventions(model)
    print(f"{model:<9} table={c['table']:<12} fk={c['foreign key']:<14} {c['controller']}")
print(conventions("OrderItem")["file"], "|", conventions("OrderItem")["routes"])

একটি request, router থেকে JSON পর্যন্ত

Rails.application.routes.draw do
  resources :products, only: %i[index show create]
end

* Puma version: 8.0.2 ("Into the Arena")
* Listening on http://127.0.0.1:8127
Started GET "/products" for 127.0.0.1 at 2026-11-01 02:20:38 +0600

  Prefix Verb URI Pattern             Controller#Action
products GET  /products(.:format)     products#index
         POST /products(.:format)     products#create
 product GET  /products/:id(.:format) products#show

Processing by ProductsController#index as */*

def index
  render json: Product.includes(:category).in_stock.order(:price)
    .as_json(only: %i[id name price], include: { category: { only: :name } })
end

Product Load (0.1ms)  SELECT "products".* FROM "products"
  WHERE (stock > 0) ORDER BY "products"."price" ASC
Category Load (0.1ms)  SELECT "categories".* FROM "categories"
  WHERE "categories"."id" IN (3, 2, 1)

Completed 200 OK in 98ms (Views: 0.1ms | ActiveRecord: 2.5ms (2 queries, 0 cached) | GC: 0.0ms)

[{"id":5,"name":"Turmeric 200g","price":95,"category":{"name":"Spices"}},
 {"id":6,"name":"Red Chilli 200g","price":110,"category":{"name":"Spices"}}, …]

৭ · Active Record, includes আর strong parameters

class Product < ApplicationRecord
  belongs_to :category
  validates :name, presence: true
  validates :price, numericality: { only_integer: true, greater_than: 0 }
  scope :in_stock, -> { where("stock > 0") }
end

Model-এ কলামের তালিকা নেই! Active Record চালু হওয়ার সময় ডেটাবেস থেকে কলাম পড়ে নেয়। এখানে লেখা থাকে শুধু সম্পর্ক, নিয়ম আর scope. Hibernate-এর Product.java-র সাথে তুলনা করুন: সেখানে প্রতিটি ঘর, constructor আর getter আলাদা লেখা।

N+1: ৭ বনাম ২, আর query cache-এর মোচড়

Hibernate-এর মতো একই পরীক্ষা, একটি rake task-এ SQL event গুনে:

সত্যিকারের run · Rails 8.1.4 · SQLite · একই ৬টি পণ্য, ৩টি ক্যাটাগরি

$ rails queries
Lazy loading: 7 queries             # Product.all.each { |p| p.category.name }
includes(:category): 2 queries     # Product.includes(:category).each { … }

$ rails queries_cache              # একই কাজ ActiveRecord::Base.cache { } -এর ভেতরে
Lazy loading, query cache on: 4 sent to SQLite, 3 from query cache
includes(:category), query cache on: 2 sent to SQLite, 0 from query cache

Rails-এ identity map নেই, তাই প্রতিটি পণ্যের ক্যাটাগরি আলাদা SQL: ১ + ৬ = ৭. Laravel আর Django-র lab-এও একই fixture-এ ৭ এসেছে। কিন্তু controller-এর ভেতরে Rails ডিফল্টে query cache চালু রাখে। তখন হুবহু একই SQL দ্বিতীয়বার ডেটাবেসে যায় না, মেমরি থেকে আসে। ফল: ৪টি SQLite পর্যন্ত গেল, ৩টি cache থেকে। অর্থাৎ বাস্তবে Hibernate-এর মতোই ৪টি যাত্রা। তবু cache ওষুধ নয়: ভিন্ন id-র জন্য query যাবেই, আর log-এ CACHE লাইনের ভিড় নিজেই N+1-এর লক্ষণ। includes সংখ্যাটিকে N থেকে মুক্ত করে ২-এ রাখে। Rails কখনো includes-কে JOIN-এও বদলায়, যদি আপনি সম্পর্কের টেবিলে where দেন, তাই log দেখে নিশ্চিত হন।

Strong parameters: params.expect

ক্লায়েন্টের পাঠানো সব ঘর সরাসরি model-এ দিলে কেউ is_admin: true পাঠিয়ে নিজেকে admin বানাতে পারে। একে বলে mass assignment, পর্ব ২৭-এ দেখেছেন। Rails-এর উত্তর strong parameters. Rails 8.0 থেকে নতুন, কড়া রূপটি params.expect; পুরোনো কোডে params.require(:product).permit(…) দেখবেন।

def create
  product = Product.new(product_params)
  if product.save
    render json: product, status: :created
  else
    render json: { errors: product.errors.full_messages }, status: :unprocessable_content
  end
end

private

def product_params
  params.expect(product: %i[category_id name price stock])
end

সত্যিকারের run · rails runner-এ চারটি ভিন্ন body · Rails 8.1.4

{"category_id" => 2, "name" => "Darjeeling Tea", "price" => 350, "stock" => 4}
{"category_id" => 2, "name" => "Free Tea", "price" => 1, "stock" => 1}      # is_admin চুপচাপ বাদ
ActionController::ParameterMissing: param is missing or the value is empty or invalid: product
ActionController::ParameterMissing: param is missing or the value is empty or invalid: product

তৃতীয় body-তে product ছিল একটি string, চতুর্থটিতে product-ই ছিল না। দুটিতেই exception, যা Rails 400 Bad Request-এ বদলায়। আর আসল server-এ যাচাই-ব্যর্থ body (নাম ফাঁকা, দাম ০) এই উত্তর পেয়েছিল:

সত্যিকারের run · 127.0.0.1 · ২০২৬-১১-০১

$ POST /products  {"product":{"category_id":2,"name":"","price":0,"stock":1}}
{"errors":["Name can't be blank","Price must be greater than 0"]}
HTTP 422
log: Completed 422 Unprocessable Content in 10ms

লক্ষ করুন, errors এখানে বাক্যের তালিকা, ঘরের নাম আলাদা নয়। ক্লায়েন্টে ঘর ধরে দেখাতে চাইলে product.errors.to_hash বা errors.as_json পাঠানো ভালো। Symbol-এর নামটিও লক্ষণীয়। পুরোনো :unprocessable_entity লিখলে আমাদের run-এ Rack 3.2.8 সতর্ক করেছে: Status code :unprocessable_entity is deprecated and will be removed in a future version of Rack. Please use :unprocessable_content instead.

নিচে params.expect-এর আচরণ JavaScript-এ একটি শেখানোর মডেল. চারটি body-র তৃতীয়টি NoSQL injection-ধাঁচের একটি চেষ্টা।

// শেখানোর মডেল: Rails-এর params.expect(product: [...]) কী করে
class ParameterMissing extends Error {}

function expect(params, key, allowed) {
  const value = params[key];
  const isHash = value !== null && typeof value === "object" && !Array.isArray(value);
  if (!isHash || Object.keys(value).length === 0) {
    throw new ParameterMissing(`param is missing or the value is empty or invalid: ${key}`);
  }
  const kept = {};
  const dropped = [];
  for (const [k, v] of Object.entries(value)) {
    const scalar = ["string", "number", "boolean"].includes(typeof v) || v === null;
    if (allowed.includes(k) && scalar) kept[k] = v;
    else dropped.push(k);
  }
  return { kept, dropped };
}

const bodies = [
  { product: { category_id: 2, name: "Darjeeling Tea", price: 350, stock: 4 } },
  { product: { category_id: 2, name: "Free Tea", price: 1, stock: 1, is_admin: true } },
  { product: { name: { $gt: "" }, price: 1 } },
  { product: "Darjeeling Tea" },
];
for (const body of bodies) {
  try {
    const { kept, dropped } = expect(body, "product", ["category_id", "name", "price", "stock"]);
    console.log("kept", JSON.stringify(kept), dropped.length ? "dropped " + dropped : "");
  } catch (e) {
    console.log("400", e.message);
  }
}

৮ · Hotwire আর Rails 8-এর ডিফল্ট

এই কোর্সের বড় অংশ React-কেন্দ্রিক: server JSON দেয়, ব্রাউজারে JavaScript পাতা আঁকে (SPA পদ্ধতি)। Rails community-র একটি বড় অংশ অন্য পথে হাঁটে, যার নাম Hotwire (“HTML over the wire”): server HTML-ই পাঠায়, আর সামান্য JavaScript পাতার অংশ বদলে দেয়। এর তিন অংশ:

আমাদের lab-এর rails new … --minimal --api আউটপুটে লেখা ছিল --skip-hotwire [due to --skip-javascript, --minimal]. অর্থাৎ সাধারণ rails new-এ Hotwire ডিফল্টে আসে। বাজারঘরের পণ্য তালিকা, ঝুড়ি আর checkout-এর মতো ফর্মভিত্তিক পাতার জন্য এটি দ্রুত আর হালকা পথ। কিন্তু খুব বেশি client state-এর অ্যাপে, যেমন offline-এ চলা app, জটিল drag-and-drop editor, বা একই API থেকে mobile app-ও চালানো, React বা অনুরূপ SPA বেশি স্বাভাবিক। কোনটি “আধুনিক” সেই বিতর্কের চেয়ে প্রশ্ন হওয়া উচিত: আপনার অ্যাপের state কোথায় থাকে? পর্ব ৩-এর (Rendering-এর মানচিত্র) MPA আর SPA-র আলোচনা এখানে মিলে যায়।

Rails 8: “Redis ছাড়াই”

Rails 8.0 (নভেম্বর ২০২৪)-এর release notes অনুযায়ী নতুন অ্যাপের ডিফল্ট:

আমাদের --minimal আউটপুটে --skip-solid, --skip-kamal আর --skip-thruster লেখা ছিল, যা থেকে বোঝা যায় 8.1.4-এও এগুলো ডিফল্টে থাকে। দর্শনটি স্পষ্ট: ছোট দল একটি ডেটাবেস আর একটি server দিয়েই অনেক দূর যেতে পারে। তবে খুব বেশি job বা cache-এর চাপে আলাদা Redis বা ব্যবস্থাপিত সেবা এখনো যুক্তিসঙ্গত। পর্ব ৪৪ (Cache) আর পর্ব ৬২-এর (Background job) প্রশ্নগুলো এখানেও খাটে। Spring জগতে এর সরাসরি একক উত্তর নেই; সেখানে সাধারণত আলাদা library আর সেবা জোড়া হয়।

৯ · সব framework, একই বাজারঘর — সৎ তুলনা আর বাছাই

প্রথমে N+1, তিনটি ORM-এ, একই fixture-এ। Hibernate আর Active Record-এর সংখ্যা এই পর্বের run থেকে, Django-র সংখ্যা একই lab থেকে, যা পর্ব ৬৮-এ বিস্তারিত আসবে।

1Hibernate  findAll() + p.getCategory()2Hibernate  @EntityGraph("category")3Rails      Product.all.each { p.category }4Rails      Product.includes(:category)5Django     Product.objects.all() + p.category6Django     .select_related("category")

এবার পুরো ছবি। যেখানে কোনো ঘর এই lab-এ মাপা হয়নি, সেখানে তাই লেখা। ভবিষ্যৎ পর্বের সংখ্যা সেই পর্বের lab থেকে এসেছে আর সেখানেই বিস্তারিত থাকবে।

একই fixture (৩টি ক্যাটাগরি, ৬টি পণ্য) · লেখার সময়ের version · একটি local কম্পিউটার · সাধারণ benchmark নয়

লাইন গোনা হয়েছে ফাঁকা লাইন বাদে, শুধু model, data access, controller, validation আর route. Seed, test আর আমাদের মাপার কোড বাদ। Spring-এর সংখ্যার বড় অংশ getter, constructor আর import, যা IDE নিজেই লেখে। তাই “Rails-এ পাঁচ গুণ কম লাইন” মানে “পাঁচ গুণ কম কাজ” নয়। বরং Spring-এর লাইনগুলো তথ্য বহন করে, যেমন type, যা compiler যাচাই করে। Rails-এ সেই তথ্য নামের নিয়ম আর ডেটাবেসে লুকানো থাকে। Vue, Nuxt, Angular আর Svelte (পর্ব ৬৬–৬৭) frontend-এর পাশ, তাই এই সারণিতে নেই; তারা ওপরের যেকোনো backend-এর সাথে চলে।

কখন কোনটি বেছে নেবেন

১০ · AI-এর যুগে Spring আর Rails

দুই framework-ই পুরোনো আর জনপ্রিয়, তাই AI-এর শেখার ডেটায় এদের পুরোনো সংস্করণের কোড বিপুল। ফলে AI প্রায়ই নির্ভুল দেখতে কিন্তু পুরোনো কোড দেয়। এই পর্বেই আমরা কয়েকটি বাস্তব ফাঁদ দেখেছি:

AI-এর Spring বা Rails কোড হাতে পেলে

• প্রতিটি dependency, annotation আর method আমার version-এর official docs-এ পেয়েছি (Spring Boot 4.1, Rails 8.1)
• Build বা rails test নিজে চালিয়েছি, আর SQL log-এ query সংখ্যা দেখেছি
• Permit-এর তালিকা বা request DTO-তে is_admin, role-এর মতো ঘর ঢুকে পড়েনি; প্রতিটি endpoint-এ authorization আছে
• Exception চাপা দেওয়া ফাঁকা catch বা rescue নেই; error-এ stack trace ক্লায়েন্টে যাচ্ছে না
• application.properties বা credentials-এ আসল secret commit হয়নি; উদাহরণে example-secret