sa-lessons/modules/module1/sections/06-quality-attributes.md

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

Навигация

• 🏠 Главная страница курса
• 📚 Модуль 1

---

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

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

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

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

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

Метрики производительности

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

Примеры требований

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"

Техники оптимизации

// Кэширование
@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)

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

Типы масштабирования

• Горизонтальное — добавление новых серверов
• Вертикальное — увеличение мощности сервера
• Автоматическое — автоматическое масштабирование

Примеры требований

scalability:
  horizontal_scaling: true
  auto_scaling:
    min_instances: 2
    max_instances: 10
    cpu_threshold: 70%
  load_balancing: "round_robin"
  database_sharding: true

Техники масштабирования

// Горизонтальное масштабирование
@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)

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

Аспекты надежности

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

Примеры требований

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"

Техники обеспечения надежности

// 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)

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

Аспекты безопасности

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

Примеры требований

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

Техники обеспечения безопасности

// 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)

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

Аспекты удобства

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

Примеры требований

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)

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

Аспекты сопровождаемости

• Читаемость кода — понятность кода
• Модульность — разделение на модули
• Тестируемость — легкость тестирования
• Документированность — наличие документации

Примеры требований

maintainability:
  code_coverage: "> 80%"
  documentation: "comprehensive"
  modularity: "high"
  test_automation: "> 90%"
  code_review: "mandatory"
  static_analysis: "enabled"

Техники обеспечения сопровождаемости

// Читаемый код
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)

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

Аспекты переносимости

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

Примеры требований

portability:
  operating_systems: ["Linux", "Windows", "macOS"]
  cloud_providers: ["AWS", "Azure", "GCP"]
  containerization: "Docker"
  orchestration: "Kubernetes"
  database_agnostic: true

Техники обеспечения переносимости

# 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. Балансируйте — не все атрибуты можно максимизировать одновременно