Spring Bootga kirish

Spring Boot - Java’da backend application tez va tartibli yozish uchun ishlatiladigan framework.

Spring Boot kirish bo‘limiga quyidagilar kiradi: Dependency Injection & IoC, Spring beans & context, REST controllers, Spring Data JPA basics, application.properties / yaml.

1. Spring Boot nima?

Oddiy Java’da backend yozsak, ko‘p narsani qo‘lda qilamiz:

• object yaratish;

• dependency ulash;

• server sozlash;

• database konfiguratsiya qilish;

• JSON parse qilish;

• HTTP request/response bilan ishlash;

• routing qilish;

• validation qilish.

Spring Boot esa bularning ko‘pini tayyor qilib beradi.

Oddiy qilib:

Spring Boot - Java’da REST API va backend service yozishni osonlashtiradigan framework.

Masalan, biz API yozmoqchimiz:

GET /users
POST /users
GET /users/{id}
DELETE /users/{id}

Spring Boot bilan buni juda tartibli yozamiz:

@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping
    public List<String> getUsers() {
        return List.of("Ali", "Vali", "Hasan");
    }
}

2. Spring vs Spring Boot

Ko‘pchilik shu joyda adashadi.

Spring Framework’da ko‘p konfiguratsiyani o‘zinmiz qilamiz.

Spring Boot’da esa ko‘p narsa auto-configured bo‘ladi.

Masalan:

• embedded Tomcat avtomatik qo‘shiladi;

• JSON converter avtomatik sozlanadi;

• database config osonlashadi;

• starter dependencylar orqali kerakli kutubxonalar keladi.

3. Spring Boot project strukturasi

Oddiy Spring Boot project:

demo-app
 ├── pom.xml
 └── src
     ├── main
     │   ├── java
     │   │   └── uz/example/demo
     │   │       ├── DemoApplication.java
     │   │       ├── controller
     │   │       ├── service
     │   │       ├── repository
     │   │       ├── entity
     │   │       └── dto
     │   └── resources
     │       ├── application.properties
     │       └── application.yml
     └── test
         └── java

Real backend’da odatda shunday package ajratiladi:

controller  -> HTTP requestlarni qabul qiladi
service     -> biznes logic
repository  -> database bilan ishlaydi
entity      -> database table model
dto         -> request/response objectlar
config      -> konfiguratsiyalar
exception   -> xatolarni boshqarish

4. Main class

Spring Boot application odatda bitta main classdan boshlanadi:

package uz.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

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

Bu yerda eng muhim annotation:

@SpringBootApplication

Bu annotation ichida uchta asosiy narsa bor:

@Configuration
@EnableAutoConfiguration
@ComponentScan

Oddiy tushuntirish:

5. IoC nima?

IoC - Inversion of Control.

Oddiy Java’da obyektlarni o‘zimiz yaratamiz:

UserRepository repository = new UserRepository();
UserService service = new UserService(repository);

Spring’da esa obyektlarni Spring yaratadi va boshqaradi.

@Service
public class UserService {
}

Spring bu classni ko‘radi, object yaratadi va container ichida saqlaydi.

Bu yondashuv IoC deyiladi.

Oddiy qilib:

Oldin obyektlarni biz boshqarardik. Spring’da obyektlarni Spring boshqaradi.

6. Dependency Injection nima?

Dependency Injection - classga kerakli dependency’ni tashqaridan berish.

Masalan, UserServicega UserRepository kerak.

Yomon usul:

public class UserService {

    private UserRepository userRepository = new UserRepository();
}

Bu yomon, chunki UserService UserRepositoryni o‘zi yaratib olyapti. Test qilish qiyinlashadi. Moslashuvchanlik kamayadi.

Yaxshi usul:

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Bu yerda UserRepository tashqaridan beriladi. Spring uni avtomatik inject qiladi.

7. Constructor injection

Spring’da eng yaxshi usul - constructor injection.

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final PaymentService paymentService;

    public OrderService(OrderRepository orderRepository,
                        PaymentService paymentService) {
        this.orderRepository = orderRepository;
        this.paymentService = paymentService;
    }
}

Nega yaxshi?

• dependency majburiy bo‘ladi;

• final ishlatish mumkin;

• test yozish oson;

• object to‘liq holatda yaratiladi;

• NullPointerException xavfi kamayadi.

7.1 Field injection

Ko‘p eski kodlarda shunday uchraydi:

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;
}

Bu ishlaydi, lekin tavsiya qilinmaydi.

Kamchiliklari:

• test qilish noqulay;

• final ishlatib bo‘lmaydi;

• dependency yashirin bo‘ladi;

• class qanday obyektlarga muhtoj ekani constructor’dan ko‘rinmaydi.

Junior uchun qoida:

Spring’da dependency injection uchun constructor injection ishlating.

8. Spring Bean nima?

Bean - Spring container boshqaradigan object.

Masalan:

@Service
public class UserService {
}

Spring UserServicedan object yaratadi. Bu object Spring bean bo‘ladi.

Bean yaratadigan annotationlar:

9. @Component

Eng umumiy annotation.

@Component
public class SmsSender {
}

Spring buni bean sifatida yaratadi.

10. @Service

Business logic yoziladigan classlarga qo‘yiladi.

@Service
public class UserService {

    public String getUserName() {
        return "Ali";
    }
}

@Service ham aslida component. Lekin ma’nosi aniqroq: bu service layer.

11. @Repository

Database bilan ishlaydigan classlarga qo‘yiladi.

@Repository
public class UserRepository {
}

Spring Data JPA’da repository odatda interface bo‘ladi:

public interface UserRepository extends JpaRepository<User, Long> {
}

Bunda @Repository yozmasak ham Spring uni repository sifatida tushunadi.

12. @RestController

REST API yozish uchun ishlatiladi.

@RestController
public class HelloController {

    @GetMapping("/hello")
    public String hello() {
        return "Hello Spring Boot";
    }
}

Browser yoki Postman’da:

GET http://localhost:8080/hello

Natija:

Hello Spring Boot

13. @Controller vs @RestController

@RestController ichida aslida:

@Controller + @ResponseBody

bor.

Backend REST API yozganda odatda @RestController ishlatiladi.

14. Request mapping

Controllerga umumiy path berish:

@RestController
@RequestMapping("/api/users")
public class UserController {
}

Endi shu controller ichidagi hamma endpoint /api/users bilan boshlanadi.

15. GET endpoint

@GetMapping
public List<String> getUsers() {
    return List.of("Ali", "Vali", "Hasan");
}

To‘liq controller:

@RestController
@RequestMapping("/api/users")
public class UserController {

    @GetMapping
    public List<String> getUsers() {
        return List.of("Ali", "Vali", "Hasan");
    }
}

Request:

GET /api/users

Response:

[
  "Ali",
  "Vali",
  "Hasan"
]

16. Path variable

URL ichidan qiymat olish uchun @PathVariable.

@GetMapping("/{id}")
public String getUserById(@PathVariable Long id) {
    return "User id: " + id;
}

Request:

GET /api/users/10

Natija:

User id: 10

17. Request param

Query parameter olish uchun @RequestParam.

@GetMapping("/search")
public String search(@RequestParam String name) {
    return "Searching user: " + name;
}

Request:

GET /api/users/search?name=Ali

Natija:

Searching user: Ali

Optional param:

@GetMapping("/search")
public String search(@RequestParam(required = false) String name) {
    return "Name: " + name;
}

Default value:

@GetMapping("/search")
public String search(@RequestParam(defaultValue = "unknown") String name) {
    return "Name: " + name;
}

18. POST endpoint

POST odatda yangi data yaratish uchun ishlatiladi.

Request body:

{
  "name": "Ali",
  "age": 25
}

DTO class:

public class CreateUserRequest {
    private String name;
    private int age;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Controller:

@PostMapping
public String createUser(@RequestBody CreateUserRequest request) {
    return "User created: " + request.getName();
}

Request:

POST /api/users

Spring JSON body’ni Java objectga o‘giradi.

19. PUT endpoint

PUT odatda mavjud datani yangilash uchun.

@PutMapping("/{id}")
public String updateUser(@PathVariable Long id,
                         @RequestBody CreateUserRequest request) {
    return "User updated: " + id + ", name: " + request.getName();
}

Request:

PUT /api/users/1

20. DELETE endpoint

@DeleteMapping("/{id}")
public String deleteUser(@PathVariable Long id) {
    return "User deleted: " + id;
}

Request:

DELETE /api/users/1

21. HTTP methodlar

REST API yozayotganda shu mappinglarni to‘g‘ri tanlashi kerak.

22. Layered architecture

Spring Boot’da kodni layerlarga ajratish juda muhim.

Controller -> Service -> Repository -> Database

Controller

HTTP requestni qabul qiladi.

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }
}

Service

Business logic yoziladi.

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Repository

Database bilan ishlaydi.

public interface UserRepository extends JpaRepository<User, Long> {
}

Qoida:

Controller database bilan to‘g‘ridan-to‘g‘ri gaplashmasin. Controller service’ni chaqirsin.

23. Entity nima?

Entity - database table’ga mos Java class.

Masalan, users table:

CREATE TABLE users (
    id BIGSERIAL PRIMARY KEY,
    name VARCHAR(100),
    age INT
);

Java entity:

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "users")
public class User {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;

    private Integer age;

    protected User() {
    }

    public User(String name, Integer age) {
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

Bu yerda:

24. JPA nima?

JPA - Java’da objectlarni database table bilan bog‘lash standarti.

Oddiy qilib:

Java object <-> database row

Masalan:

User user = new User("Ali", 25);

JPA buni database’ga yozib beradi:

INSERT INTO users (name, age) VALUES ('Ali', 25);

JPA - standart.
Hibernate - JPA’ning eng mashhur implementation’i.
Spring Data JPA - JPA bilan ishlashni juda osonlashtiradi.

25. Spring Data JPA Repository

Repository interface:

import org.springframework.data.jpa.repository.JpaRepository;

public interface UserRepository extends JpaRepository<User, Long> {
}

Shu bilan Spring bizga tayyor methodlar beradi:

save()
findById()
findAll()
deleteById()
existsById()
count()

Masalan:

userRepository.findAll();
userRepository.findById(1L);
userRepository.save(user);
userRepository.deleteById(1L);

Biz JDBC’dagi kabi Connection, PreparedStatement, ResultSet yozmaymiz. Spring Data JPA buni ichkarida qiladi.

26. Service example

@Service
public class UserService {

    private final UserRepository userRepository;

    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }

    public List<User> findAll() {
        return userRepository.findAll();
    }

    public User findById(Long id) {
        return userRepository.findById(id)
                .orElseThrow(() -> new RuntimeException("User topilmadi"));
    }

    public User create(String name, Integer age) {
        User user = new User(name, age);
        return userRepository.save(user);
    }

    public void deleteById(Long id) {
        userRepository.deleteById(id);
    }
}

27. Controller + Service

@RestController
@RequestMapping("/api/users")
public class UserController {

    private final UserService userService;

    public UserController(UserService userService) {
        this.userService = userService;
    }

    @GetMapping
    public List<User> findAll() {
        return userService.findAll();
    }

    @GetMapping("/{id}")
    public User findById(@PathVariable Long id) {
        return userService.findById(id);
    }

    @PostMapping
    public User create(@RequestBody CreateUserRequest request) {
        return userService.create(request.getName(), request.getAge());
    }

    @DeleteMapping("/{id}")
    public void deleteById(@PathVariable Long id) {
        userService.deleteById(id);
    }
}

Bu minimal CRUD API.

28. DTO nima?

DTO - Data Transfer Object.

DTO API orqali kiradigan yoki chiqadigan data uchun ishlatiladi.

Nega entity’ni to‘g‘ridan-to‘g‘ri qaytarish yomon bo‘lishi mumkin?

• database fieldlari tashqariga chiqib ketishi mumkin;

• password kabi maxfiy field chiqishi mumkin;

• entity relationlari recursive JSON muammo berishi mumkin;

• API response database modelga qattiq bog‘lanib qoladi.

Yaxshiroq:

public class UserResponse {
    private Long id;
    private String name;
    private Integer age;

    public UserResponse(Long id, String name, Integer age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

Mapping:

public UserResponse toResponse(User user) {
    return new UserResponse(
            user.getId(),
            user.getName(),
            user.getAge()
    );
}

Controller response:

@GetMapping("/{id}")
public UserResponse findById(@PathVariable Long id) {
    User user = userService.findById(id);

    return new UserResponse(user.getId(), user.getName(), user.getAge());
}

29. application.properties

Spring Boot sozlamalari src/main/resources/application.properties ichida yoziladi.

PostgreSQL config:

spring.datasource.url=jdbc:postgresql://localhost:5432/demo_db
spring.datasource.username=postgres
spring.datasource.password=password

spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true
spring.jpa.properties.hibernate.format_sql=true

Bu yerda:

30. application.yml

Xuddi shu config YAML’da:

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/demo_db
    username: postgres
    password: password

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
    properties:
      hibernate:
        format_sql: true

properties va yml ikkalasi ham ishlaydi.

Boshlanishiga bittasini tanlab, doimiy ishlatish yetarli. Ko‘p real loyihalarda application.yml ko‘proq o‘qilishi qulay bo‘lgani uchun ishlatiladi.

31. ddl-auto nima?

spring.jpa.hibernate.ddl-auto entitylarga qarab database schema bilan nima qilishni belgilaydi.

Oddiy holat/local uchun:

spring.jpa.hibernate.ddl-auto=update

ishlatish mumkin.

Production uchun ehtiyot bo‘lish kerak. Real production’da ko‘pincha:

spring.jpa.hibernate.ddl-auto=validate

va migration tool ishlatiladi:

Flyway yoki Liquibase

32. Spring Boot starterlar

Starter - kerakli dependencylar to‘plami.

Masalan, REST API uchun:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

JPA uchun:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>

PostgreSQL driver:

<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <scope>runtime</scope>
</dependency>

Validation uchun:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-validation</artifactId>
</dependency>

Test uchun:

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
</dependency>

33. Minimal Spring Boot pom.xml

<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
         https://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.3.2</version>
        <relativePath/>
    </parent>

    <groupId>uz.example</groupId>
    <artifactId>demo-api</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <properties>
        <java.version>21</java.version>
    </properties>

    <dependencies>
        <!-- REST API -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <!-- JPA -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

        <!-- PostgreSQL -->
        <dependency>
            <groupId>org.postgresql</groupId>
            <artifactId>postgresql</artifactId>
            <scope>runtime</scope>
        </dependency>

        <!-- Validation -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-validation</artifactId>
        </dependency>

        <!-- Test -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

34. Validation intro

Request body’ni tekshirish uchun validation ishlatiladi.

DTO:

import jakarta.validation.constraints.Min;
import jakarta.validation.constraints.NotBlank;

public class CreateUserRequest {

    @NotBlank(message = "Name bo'sh bo'lishi mumkin emas")
    private String name;

    @Min(value = 1, message = "Age kamida 1 bo'lishi kerak")
    private Integer age;

    public String getName() {
        return name;
    }

    public Integer getAge() {
        return age;
    }
}

Controller:

@PostMapping
public UserResponse create(@Valid @RequestBody CreateUserRequest request) {
    return userService.create(request);
}

@Valid requestni controllerga kirishdan oldin tekshiradi.

35. ResponseEntity

ResponseEntity HTTP statusni boshqarish uchun ishlatiladi.

@GetMapping("/{id}")
public ResponseEntity<UserResponse> findById(@PathVariable Long id) {
    UserResponse response = userService.findById(id);

    return ResponseEntity.ok(response);
}

Create uchun:

@PostMapping
public ResponseEntity<UserResponse> create(@RequestBody CreateUserRequest request) {
    UserResponse response = userService.create(request);

    return ResponseEntity.status(201).body(response);
}

201 Created - yangi resource yaratildi degani.

36. Exception handling intro

Yomon holat:

throw new RuntimeException("User topilmadi");

Bu ishlaydi, lekin API response chiroyli bo‘lmaydi.

Yaxshiroq custom exception:

public class NotFoundException extends RuntimeException {

    public NotFoundException(String message) {
        super(message);
    }
}

Service:

public User findById(Long id) {
    return userRepository.findById(id)
            .orElseThrow(() -> new NotFoundException("User topilmadi"));
}

Global exception handler:

@RestControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(NotFoundException.class)
    public ResponseEntity<String> handleNotFound(NotFoundException ex) {
        return ResponseEntity.status(404).body(ex.getMessage());
    }
}

Endi user topilmasa:

HTTP 404
User topilmadi

qaytadi.

37. Mini CRUD loyiha

Loyiha: User Management API

Endpointlar:

Package structure:

uz.example.demo
 ├── DemoApplication.java
 ├── controller
 │   └── UserController.java
 ├── service
 │   └── UserService.java
 ├── repository
 │   └── UserRepository.java
 ├── entity
 │   └── User.java
 ├── dto
 │   ├── CreateUserRequest.java
 │   ├── UpdateUserRequest.java
 │   └── UserResponse.java
 └── exception
     ├── NotFoundException.java
     └── GlobalExceptionHandler.java

38. Boshlang'ichlar qiladigan xatolar

Xato 1: Controller ichida business logic yozish

Yomon:

@PostMapping
public User create(@RequestBody CreateUserRequest request) {
    if (request.getAge() < 18) {
        throw new RuntimeException("Age invalid");
    }

    User user = new User(request.getName(), request.getAge());

    return userRepository.save(user);
}

Yaxshi:

@PostMapping
public UserResponse create(@RequestBody CreateUserRequest request) {
    return userService.create(request);
}

Business logic service’da bo‘lsin.

Xato 2: Entity’ni to‘g‘ridan-to‘g‘ri response qilish

Kichik demo uchun mumkin. Real loyihada DTO ishlatish yaxshiroq.

Xato 3: Field injection ishlatish

Yomon:

@Autowired
private UserService userService;

Yaxshi:

private final UserService userService;

public UserController(UserService userService) {
    this.userService = userService;
}

Xato 4: ddl-auto=updateni production’da ishlatish

Local developmentda qulay. Production’da migration tool bilan ishlash yaxshiroq.

Xato 5: Repository’ni Controllerdan to‘g‘ridan-to‘g‘ri chaqirish

Yomon:

@RestController
public class UserController {

    private final UserRepository userRepository;
}

Yaxshi:

Controller -> Service -> Repository

39. Boshlang'ich uchun eng muhim qismlar

40. Amaliy mashq

Vazifa: Product API

Quyidagi API’ni yozing.

Entity

@Entity
@Table(name = "products")
public class Product {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private BigDecimal price;
    private Boolean active;

    protected Product() {
    }

    public Product(String name, BigDecimal price, Boolean active) {
        this.name = name;
        this.price = price;
        this.active = active;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public BigDecimal getPrice() {
        return price;
    }

    public Boolean getActive() {
        return active;
    }
}

Repository

public interface ProductRepository extends JpaRepository<Product, Long> {
    List<Product> findByActiveTrue();
}

Endpointlar

Xulosa

Spring Boot Intro - Java backend developer uchun asosiy turning point.

Shu bosqichdan keyin biz oddiy Java’dan real backend API yozishga o‘tamiz.

Eng muhim zanjir:

HTTP Request
   ↓
Controller
   ↓
Service
   ↓
Repository
   ↓
Database

Eng kerakli annotationlar:

@SpringBootApplication
@RestController
@RequestMapping
@GetMapping
@PostMapping
@Service
@Repository
@Entity
@Id
@RequestBody
@PathVariable

Asosiy qoida:

Controller request/response bilan ishlaydi. Service business logic bilan ishlaydi. Repository database bilan ishlaydi.