Как бы просматривал Instance

# Как бы просматривал Instance

Под "просмотром instance" имеется в виду отладка и анализ состояния объекта во время выполнения. Это критичный навык при отладке production issues. Расскажу о всех основных подходах.

1. Debugger (IDE Debug Mode)

Способ 1: Breakpoints в IDE

Самый удобный способ — использовать встроенный debugger:

public class OrderService {
    public OrderDTO getOrder(Long id) {
        Order order = orderRepository.findById(id); // ← Поставить breakpoint
        order.validate();
        return orderMapper.toDTO(order);
    }
}

В IDE (IntelliJ IDEA):

1. Нажать левую кнопку мыши на левом краю строки → Красная точка (breakpoint)
2. Запустить приложение в Debug режиме (Shift+F9)
3. Когда выполнение достигнет breakpoint, приложение остановится
4. Просмотреть состояние:
   • Variables tab: все переменные и их значения
   • Watches: добавить выражения для отслеживания
   • Frames: стек вызовов

breakpoint: order = {...}

Variables:
  order (Order)
    - id: 123
    - status: "PENDING"
    - items: [{...}, {...}]
    - total: 999.99
    - createdAt: 2024-03-22T10:30:00Z

Условные Breakpoints

public void processOrders(List<Order> orders) {
    for (Order order : orders) {
        processOrder(order); // ← Breakpoint (conditional)
    }
}

// Breakpoint срабатывает только когда order.id == 123
// Условие: order.getId() == 123

Логические точки останова (Logpoints)

public class PaymentService {
    public void processPayment(Payment payment) {
        // Вместо breakpoint, можно добавить "logpoint"
        // Это выведет значение в консоль без остановки
        // Условие: {payment.getAmount() > 1000}
        // Сообщение: "High payment: {payment.getAmount()}"
        payment.process();
    }
}

// В консоли:
// High payment: 5000.00
// High payment: 2500.50

2. Reflection API (Исследование объекта во время выполнения)

public class InstanceInspector {
    
    public static void inspectInstance(Object obj) {
        Class<?> clazz = obj.getClass();
        
        System.out.println("=== Object Inspection ===");
        System.out.println("Type: " + clazz.getName());
        System.out.println("Package: " + clazz.getPackage().getName());
        System.out.println("Modifiers: " + Modifier.toString(clazz.getModifiers()));
        
        // 1. Все поля (Fields)
        System.out.println("\n--- Fields ---");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            field.setAccessible(true); // Даже private поля
            System.out.println("  " + field.getName() + 
                             ": " + field.getType().getSimpleName() + 
                             " = " + field.get(obj));
        }
        
        // 2. Все методы (Methods)
        System.out.println("\n--- Methods ---");
        Method[] methods = clazz.getDeclaredMethods();
        for (Method method : methods) {
            System.out.println("  " + method.getName() + 
                             "(" + Arrays.toString(method.getParameterTypes()) + ")");
        }
        
        // 3. Все конструкторы (Constructors)
        System.out.println("\n--- Constructors ---");
        Constructor<?>[] constructors = clazz.getDeclaredConstructors();
        for (Constructor<?> constructor : constructors) {
            System.out.println("  " + constructor);
        }
    }
}

// Пример использования
Order order = new Order(123L, "PENDING", 999.99);
InstanceInspector.inspectInstance(order);

// Вывод:
// === Object Inspection ===
// Type: com.example.Order
// Package: com.example
// Modifiers: public
// 
// --- Fields ---
//   id: Long = 123
//   status: String = PENDING
//   total: Double = 999.99
//   items: List = [{...}, {...}]
//
// --- Methods ---
//   getStatus()
//   setStatus(String)
//   validate()
//   ...

3. ObjectMapper & JSON сериализация

Сильно помогает при отладке сложных объектов:

public class InstanceViewer {
    private static final ObjectMapper mapper = new ObjectMapper();
    
    static {
        mapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
        mapper.writerWithDefaultPrettyPrinter();
    }
    
    public static void printInstance(Object obj) throws JsonProcessingException {
        String json = mapper.writerWithDefaultPrettyPrinter()
            .writeValueAsString(obj);
        System.out.println(json);
    }
}

// Использование:
Order order = orderRepository.findById(123L);
InstanceViewer.printInstance(order);

// Вывод:
// {
//   "id": 123,
//   "status": "PENDING",
//   "total": 999.99,
//   "items": [
//     {
//       "id": 1,
//       "name": "Laptop",
//       "price": 999.99
//     },
//     {
//       "id": 2,
//       "name": "Mouse",
//       "price": 25.00
//     }
//   ],
//   "createdAt": "2024-03-22T10:30:00Z"
// }

4. toString() переопределение

@Entity
public class Order {
    private Long id;
    private String status;
    private Double total;
    private List<OrderItem> items;
    
    @Override
    public String toString() {
        return "Order{" +
                "id=" + id +
                ", status='" + status + '\'' +
                ", total=" + total +
                ", items=" + items +
                '}';
    }
}

// При логировании
logger.info("Processing order: " + order);
// Вывод: Processing order: Order{id=123, status='PENDING', total=999.99, items=[...]}

Или используй Lombok:

@Entity
@ToString(exclude = {"items"}) // Исключить большие коллекции
public class Order {
    private Long id;
    private String status;
    private Double total;
    private List<OrderItem> items;
}

5. Lombok @Getter / IntelliJ структурный view

В IDE есть встроенный "Structure" view:

Order (файл)
├─ id: Long
├─ status: String
├─ total: Double
├─ items: List<OrderItem>
├─ getId()
├─ getStatus()
├─ setStatus(String)
├─ validate()
├─ toString()
└─ equals(Object)

А при отладке:

Variables:
┌─ order: Order
│ ├─ id = 123
│ ├─ status = "PENDING"
│ ├─ total = 999.99
│ └─ items: List (size=2)
│   ├─ [0]: OrderItem
│   │ ├─ id = 1
│   │ ├─ name = "Laptop"
│   │ └─ price = 999.99
│   └─ [1]: OrderItem
│     ├─ id = 2
│     ├─ name = "Mouse"
│     └─ price = 25.00

6. Логирование и структурированные логи

@Service
public class OrderService {
    private static final Logger logger = LoggerFactory.getLogger(OrderService.class);
    
    public void processOrder(Order order) {
        // Структурированное логирование с context
        MDC.put("orderId", order.getId().toString());
        MDC.put("customerId", order.getCustomerId().toString());
        
        try {
            logger.info(
                "Processing order: id={}, status={}, total={}",
                order.getId(),
                order.getStatus(),
                order.getTotal()
            );
            
            // Более детальное логирование
            if (logger.isDebugEnabled()) {
                logger.debug("Order items: {}", order.getItems());
                logger.debug("Order customer: {}", order.getCustomer());
            }
            
            order.process();
            logger.info("Order processed successfully");
            
        } catch (Exception e) {
            logger.error("Error processing order", e);
            throw e;
        } finally {
            MDC.clear();
        }
    }
}

// В логах:
// 2024-03-22 10:30:00 INFO [orderId=123, customerId=456] Processing order: id=123, status=PENDING, total=999.99
// 2024-03-22 10:30:00 DEBUG [orderId=123] Order items: [OrderItem(...), OrderItem(...)]
// 2024-03-22 10:30:01 INFO [orderId=123] Order processed successfully

7. JVM Internals - Как просмотреть память

jps - Java Process Status

$ jps
12345 OrderServiceApplication
12346 PaymentServiceApplication

jcmd - JVM Command Line Interface

# Посмотреть все потоки
$ jcmd 12345 Thread.print

# Dump heap
$ jcmd 12345 GC.heap_dump /tmp/heap.hprof

# Посмотреть VM flags
$ jcmd 12345 VM.flags

jvisualvm - Visual JVM Monitor

Гра фический инструмент для мониторинга:

jvisualvm
├─ Threads (потоки)
├─ Memory (память, heap)
├─ CPU (нагрузка)
├─ GC (сборка мусора)
└─ Sampler (профилирование)

8. Практический сценарий: Отладка Production Issue

// Проблема: некоторые заказы имеют неправильный статус

@RestController
@RequestMapping("/api/orders")
public class OrderController {
    
    @GetMapping("/{id}")
    public OrderDTO getOrder(@PathVariable Long id) {
        Order order = orderService.getOrder(id);
        
        // Точка для отладки (breakpoint)
        if (order.getStatus() == null) {
            // Логируем детали проблемы
            logger.error(
                "Order has null status. Details: " +
                "id={}, createdAt={}, customer={}",
                order.getId(),
                order.getCreatedAt(),
                order.getCustomer()
            );
            
            // Или более детально через Reflection
            InstanceInspector.inspectInstance(order);
        }
        
        return orderMapper.toDTO(order);
    }
}

// Вывод логов:
// ERROR Order has null status. Details: id=999, createdAt=2024-01-15T08:00:00Z, customer=Customer{id=456, email=john@example.com}
// === Object Inspection ===
// Type: com.example.Order
// --- Fields ---
//   id: Long = 999
//   status: String = null ← ПРОБЛЕМА!
//   total: Double = 1500.00
//   items: List = [{...}]

9. Через REST API (для remote instance inspection)

@RestController
@RequestMapping("/api/debug")
public class DebugController {
    
    @GetMapping("/instance/{id}")
    public Map<String, Object> inspectInstance(@PathVariable Long id) {
        Order order = orderService.getOrder(id);
        
        Map<String, Object> result = new LinkedHashMap<>();
        result.put("type", order.getClass().getName());
        result.put("id", order.getId());
        result.put("status", order.getStatus());
        result.put("total", order.getTotal());
        result.put("items_count", order.getItems().size());
        result.put("created_at", order.getCreatedAt());
        
        return result;
    }
}

// curl http://localhost:8080/api/debug/instance/123
// {
//   "type": "com.example.Order",
//   "id": 123,
//   "status": "PENDING",
//   "total": 999.99,
//   "items_count": 2,
//   "created_at": "2024-03-22T10:30:00Z"
// }

Мой практический подход

Шаг 1: Быстрая отладка (локально)

• Поставить breakpoint в IDE
• Запустить в Debug режиме
• Смотреть состояние переменных

Шаг 2: Структурное логирование (production)

• Добавить structured logs (JSON)
• Использовать MDC для context
• Логировать state изменения

Шаг 3: Глубокий анализ (если нужен)

• Добавить временный endpoint для inspect
• Использовать Reflection если нужна гибкость
• Dump heap для анализа утечек памяти

Шаг 4: Долгосрочное решение

• Добавить unit тесты для воспроизведения
• Улучшить логирование
• Документировать найденную проблему

Вывод

Просмотр instance — это не один способ, а целый арсенал:

1. IDE Debugger — лучше всего для локальной разработки
2. Reflection API — когда нужна гибкость
3. JSON сериализация — для визуализации
4. Структурированные логи — для production
5. JVM tools — для глубокого анализа

Оптимальный подход сочетает все эти техники в зависимости от ситуации.