# Качественные атрибуты

## Навигация
- [🏠 Главная страница курса](../../../README.md)
- [📚 Модуль 1](../README.md)

---

## Определение качественных атрибутов

**Качественные атрибуты** — это характеристики системы, которые определяют, насколько хорошо система выполняет свои функции с точки зрения пользователей и заинтересованных сторон.

## Основные качественные атрибуты

### 1. Производительность (Performance)

**Определение:** Скорость и эффективность выполнения операций системой.

#### Метрики производительности
- **Время отклика** — время между запросом и ответом
- **Пропускная способность** — количество операций в единицу времени
- **Использование ресурсов** — CPU, память, диск, сеть
- **Время загрузки** — время запуска приложения

#### Примеры требований
```yaml
performance:
  response_time:
    average: "< 200ms"
    p95: "< 500ms"
    p99: "< 1000ms"
  throughput:
    requests_per_second: 1000
    concurrent_users: 10000
  resource_usage:
    cpu: "< 70%"
    memory: "< 2GB"
    disk_io: "< 100MB/s"
```

#### Техники оптимизации
```java
// Кэширование
@Service
public class UserService {
    
    @Cacheable("users")
    public User findById(Long id) {
        return userRepository.findById(id);
    }
    
    @CacheEvict("users")
    public void updateUser(User user) {
        userRepository.save(user);
    }
}

// Асинхронная обработка
@Service
public class OrderService {
    
    @Async
    public CompletableFuture<Order> processOrderAsync(Order order) {
        // Длительная обработка
        return CompletableFuture.completedFuture(order);
    }
}

// Пакетная обработка
@Service
public class BatchProcessor {
    
    public void processBatch(List<Order> orders) {
        // Обработка пакетами по 100
        Lists.partition(orders, 100)
            .forEach(this::processBatch);
    }
}
```

### 2. Масштабируемость (Scalability)

**Определение:** Способность системы обрабатывать увеличение нагрузки.

#### Типы масштабирования
- **Горизонтальное** — добавление новых серверов
- **Вертикальное** — увеличение мощности сервера
- **Автоматическое** — автоматическое масштабирование

#### Примеры требований
```yaml
scalability:
  horizontal_scaling: true
  auto_scaling:
    min_instances: 2
    max_instances: 10
    cpu_threshold: 70%
  load_balancing: "round_robin"
  database_sharding: true
```

#### Техники масштабирования
```java
// Горизонтальное масштабирование
@RestController
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/users/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // Load balancer распределяет нагрузку
        User user = userService.findById(id);
        return ResponseEntity.ok(user);
    }
}

// Шардирование базы данных
@Service
public class UserService {
    
    @Autowired
    private List<UserRepository> userRepositories;
    
    public User findById(Long id) {
        // Определение шарда по ID
        int shardIndex = (int) (id % userRepositories.size());
        return userRepositories.get(shardIndex).findById(id);
    }
}
```

### 3. Надежность (Reliability)

**Определение:** Способность системы выполнять требуемые функции в заданных условиях.

#### Аспекты надежности
- **Отказоустойчивость** — работа при сбоях
- **Восстановление** — быстрое восстановление после сбоев
- **Предотвращение потери данных** — сохранность данных

#### Примеры требований
```yaml
reliability:
  availability: "99.9%"
  mean_time_to_recovery: "< 5 minutes"
  data_loss: "0%"
  backup_frequency: "every 6 hours"
  disaster_recovery: "RTO < 1 hour, RPO < 15 minutes"
```

#### Техники обеспечения надежности
```java
// Circuit Breaker
@Component
public class PaymentService {
    
    private final CircuitBreaker circuitBreaker;
    
    public PaymentService() {
        this.circuitBreaker = CircuitBreaker.ofDefaults("payment");
    }
    
    public PaymentResult processPayment(PaymentRequest request) {
        return circuitBreaker.executeSupplier(() -> {
            // Вызов внешнего сервиса
            return externalPaymentService.process(request);
        });
    }
}

// Retry механизм
@Service
public class OrderService {
    
    @Retryable(value = {Exception.class}, maxAttempts = 3)
    public Order createOrder(OrderRequest request) {
        return orderRepository.save(new Order(request));
    }
    
    @Recover
    public Order recover(Exception ex, OrderRequest request) {
        // Fallback логика
        return new Order(request, OrderStatus.FAILED);
    }
}
```

### 4. Безопасность (Security)

**Определение:** Защита системы от угроз и несанкционированного доступа.

#### Аспекты безопасности
- **Аутентификация** — проверка личности пользователя
- **Авторизация** — проверка прав доступа
- **Шифрование** — защита данных
- **Аудит** — отслеживание действий

#### Примеры требований
```yaml
security:
  authentication: "JWT tokens"
  authorization: "RBAC"
  encryption:
    data_at_rest: "AES-256"
    data_in_transit: "TLS 1.3"
  password_policy:
    min_length: 8
    complexity: "uppercase, lowercase, numbers, symbols"
  session_timeout: "30 minutes"
  audit_logging: true
```

#### Техники обеспечения безопасности
```java
// JWT аутентификация
@RestController
public class AuthController {
    
    @PostMapping("/login")
    public ResponseEntity<AuthResponse> login(@RequestBody LoginRequest request) {
        User user = userService.authenticate(request.getUsername(), request.getPassword());
        String token = jwtService.generateToken(user);
        return ResponseEntity.ok(new AuthResponse(token));
    }
}

// RBAC авторизация
@PreAuthorize("hasRole('ADMIN') or hasRole('USER')")
@GetMapping("/users/{id}")
public ResponseEntity<User> getUser(@PathVariable Long id) {
    User user = userService.findById(id);
    return ResponseEntity.ok(user);
}

// Шифрование данных
@Service
public class EncryptionService {
    
    public String encrypt(String data) {
        // AES шифрование
        return aesEncryptor.encrypt(data);
    }
    
    public String decrypt(String encryptedData) {
        // AES расшифровка
        return aesEncryptor.decrypt(encryptedData);
    }
}
```

### 5. Удобство использования (Usability)

**Определение:** Легкость использования системы пользователями.

#### Аспекты удобства
- **Интуитивность** — понятность интерфейса
- **Производительность** — скорость выполнения задач
- **Обучаемость** — легкость изучения
- **Доступность** — доступность для людей с ограниченными возможностями

#### Примеры требований
```yaml
usability:
  response_time: "< 2 seconds"
  error_messages: "clear and helpful"
  navigation: "intuitive"
  accessibility: "WCAG 2.1 AA"
  mobile_responsive: true
  browser_support: "Chrome, Firefox, Safari, Edge"
```

### 6. Сопровождаемость (Maintainability)

**Определение:** Легкость внесения изменений в систему.

#### Аспекты сопровождаемости
- **Читаемость кода** — понятность кода
- **Модульность** — разделение на модули
- **Тестируемость** — легкость тестирования
- **Документированность** — наличие документации

#### Примеры требований
```yaml
maintainability:
  code_coverage: "> 80%"
  documentation: "comprehensive"
  modularity: "high"
  test_automation: "> 90%"
  code_review: "mandatory"
  static_analysis: "enabled"
```

#### Техники обеспечения сопровождаемости
```java
// Читаемый код
public class OrderService {
    
    public Order createOrder(CreateOrderRequest request) {
        validateRequest(request);
        Order order = buildOrder(request);
        Order savedOrder = saveOrder(order);
        notifyCustomer(savedOrder);
        return savedOrder;
    }
    
    private void validateRequest(CreateOrderRequest request) {
        if (request == null) {
            throw new IllegalArgumentException("Request cannot be null");
        }
        // Дополнительная валидация
    }
    
    private Order buildOrder(CreateOrderRequest request) {
        return Order.builder()
            .customerId(request.getCustomerId())
            .items(request.getItems())
            .status(OrderStatus.DRAFT)
            .build();
    }
}

// Тестируемый код
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    
    @Mock
    private OrderRepository orderRepository;
    
    @InjectMocks
    private OrderService orderService;
    
    @Test
    void shouldCreateOrder() {
        // Given
        CreateOrderRequest request = new CreateOrderRequest();
        Order expectedOrder = new Order();
        when(orderRepository.save(any(Order.class))).thenReturn(expectedOrder);
        
        // When
        Order result = orderService.createOrder(request);
        
        // Then
        assertThat(result).isEqualTo(expectedOrder);
        verify(orderRepository).save(any(Order.class));
    }
}
```

### 7. Переносимость (Portability)

**Определение:** Способность системы работать в разных средах.

#### Аспекты переносимости
- **Платформенная независимость** — работа на разных ОС
- **Облачная совместимость** — работа в разных облаках
- **Контейнеризация** — упаковка в контейнеры

#### Примеры требований
```yaml
portability:
  operating_systems: ["Linux", "Windows", "macOS"]
  cloud_providers: ["AWS", "Azure", "GCP"]
  containerization: "Docker"
  orchestration: "Kubernetes"
  database_agnostic: true
```

#### Техники обеспечения переносимости
```yaml
# Dockerfile
FROM openjdk:11-jre-slim
COPY target/app.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

# docker-compose.yml
version: '3.8'
services:
  app:
    build: .
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=docker
    depends_on:
      - database
  
  database:
    image: postgres:13
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: user
      POSTGRES_PASSWORD: password
```

## Приоритизация качественных атрибутов

### Матрица приоритетов
| Атрибут | Критичность | Сложность | Приоритет |
|---------|-------------|-----------|-----------|
| Производительность | Высокая | Средняя | Высокий |
| Безопасность | Высокая | Высокая | Высокий |
| Надежность | Высокая | Высокая | Высокий |
| Масштабируемость | Средняя | Высокая | Средний |
| Удобство использования | Средняя | Средняя | Средний |
| Сопровождаемость | Средняя | Низкая | Средний |
| Переносимость | Низкая | Средняя | Низкий |

### Рекомендации
1. **Начните с критичных атрибутов** — безопасность, надежность
2. **Учитывайте контекст** — разные требования для разных систем
3. **Планируйте заранее** — некоторые атрибуты сложно добавить позже
4. **Измеряйте прогресс** — используйте метрики для отслеживания
5. **Балансируйте** — не все атрибуты можно максимизировать одновременно