class ScaleUploadJob {

// константы
// 44 зависимости в приватных полях
// 9 мутабельных состояний

//конструкторы, конструкторы для тестов

  public void run() {
    TransportClient client = null;
    DataHandler handler;

    try {
      while (shouldContinue()) {
        try (DbSession session = getSession()) {
          while (hasWork()) {
            DeviceInfo info = loadDeviceInfo(session);

            if (shouldAbort(info)) {
              break;
            }

            pump(info);

            if (shouldBulkLoad(info)) {
              processData(session, handler, info);
            } else if (shouldSyncMetadata(info)) {
              handleSyncMetadata(info, handler, session);
            } else if (shouldSyncImages(info)) {
              handleSyncImages(info, handler, session);
            } else {
              handleApplyUpdates(session, handler, info);
            }
          }
        } catch (Exception ex) {
          handleException(client, ex);
        } finally {
          closeClient(client);
        }
      }
    } finally {
      cleanupResources();
    }
  }

  /**
  * основная логика работы на 200+ строк
  */
  protected void processData(Session session, DataHandler handler, DeviceInfo device)
      throws DataException, NetworkException, ProtocolException, InterruptedException {

    ItemsCursor cursor = null;
    ItemsMetadata meta = null;
    ErrorReason reason = null;

    initRemovalSet();
    uploadEmblem(handler);
    meta = loadItemsMetadata(session, device.getId());

    try {
      setupRemovalRanges(session, device);
      long syncId = getMaxSyncId(session);
      GroupRegistry groups = loadGroupRegistry(session, device.getId());

      cursor = itemRepository.openCursor(session, buildSchema(), getBatchSize());
      syncGroups(device, session, handler, groups);

      List<ProductData> buffer = new LinkedList<>();

      while (hasMoreItems(session, cursor)) {
        processNextBatch(session, cursor, groups, device, buffer);
        if (buffer.size() >= getBatchSize()) {
          flushBuffer(handler, buffer, null);
          buffer.clear();
        }
      }

      if (!buffer.isEmpty()) {
        finalizeBatch(buffer, device, session);
      }

      purgeItems(handler, device, removalSet);
      updateSyncStatus(session, device, syncId);

    } catch (Exception ex) {
      reason = this.getReason(ex);
      handleFailure(session, device, reason, ex);
    } finally {
      cleanup(session, device, cursor, meta, reason);
    }
  }

  private void purgeItems() {

  }

  //прочие приватные методы
// в общей сложности - 1700 строк кода
}

// интерфейс отправки данных в весы
// вызывается в одном из приватных методов
public interface DataUploader {
  void submitProducts(List<ProductRecord> items) throws Exception;
  void submitProducts(List<ProductRecord> items, CallbackHandler<UploadContext, UploadResult> handler) throws Exception;
  // 18 прочих методов, из которых 8 - также дублируются
}

// реализация для одного устройства
public class FirstDeviceModelDataUploader implements DataUploader {
  @Override
  public void submitProducts(List<ProductRecord> items) {
    throw new UnsupportedOperationException();
  }
  @Override
  public void submitProducts(List<ProductRecord> items, CallbackHandler<UploadContext, UploadResult> handler) {
    throw new UnsupportedOperationException();
  }
  //...
}

// реализация для другого устройства
public class SecondDeviceModelDataLoader implements DataUploader {
  @Override
  public void submitProducts(List<ProductRecord> items) {
    submitProducts(items, null);
  }

  @Override
  public void submitProducts(List<ProductRecord> items, CallbackHandler<UploadContext, UploadResult> handler) {
    List<Integer> invalid = new ArrayList<>();
    int position = 0;
    int batchSize = loaderConfig.getImageBatchSize(config);

    for (ProductRecord product : items) {
      if (isValid(product)) {
        position++;
        CallbackRecorder recorder = createCallback(handler, product);

        //следующие вызовы - отправка данных на устройства
        syncBasicData(product, recorder);
        syncAttributes(product, recorder);
        syncLabels(product, recorder);
        syncMessages(product, recorder);
        syncImage(product, batchSize, recorder);

        position = applyThrottling(position, config);
        finalizeCallback(recorder);
      } else {
        invalid.add(product.getId());
      }
    }

    if (!invalid.isEmpty()) {
      purgeInvalidRecords(invalid);
    }
  }
}

// Наиболее общий Device содержит DeviceConfig, одно подключение и отображение типов сообщений к конвертерам.
public class BaseDevice<I> implements Device<I> {

    protected final DeviceConfig<I> info;
    private final Network network;
    private final Map<Class<? extends Message>, MessageMapper<I, ? extends Message>> mapperMap;
    // constructors, getters, setters

    @Override
    public void initialize() throws NetworkException {
        network.connect();
    }

    @Override
    public void shutdown() {
        network.close();
    }

    @Override
    public MessageResponse send(Message message) throws MessageFormatException, MessageSendingException {
        MessageMapper<I, ? extends Message> mapper = mapperMap.get(message.getClass());
        if (mapper == null) {
            throw new MessageFormatException(
                    "Весы (" + this.info + ") не поддерживают отправку данного сообщения: " + message,
                    message
            );
        }

        Collection<Input> inputs = mapper.convert(message);

        Collection<Output> outputs = new ArrayList<>();
        for (Input input : inputs) {
            Output output;
            try {
                output = network.send(input);
            } catch (DataSendingException e) {
                throw new MessageSendingException(message, e);
            }
            outputs.add(output);
        }

        return mapper.convert(outputs);
    }
}

public abstract class BaseDeviceFactory<I> implements DeviceFactory<I> {

    protected final NetworkFactoryManager networkFactory;
    private final MessageMapperManager<I> mapperFactory;

    // constructors

    /**
    * потомок обязуется получать информацию о подключению из информации об устройстве
    */
    protected abstract NetworkConfig extractNetworkConfig(DeviceConfig<I> info);

    @Override
    public Device<I> createDevice(DeviceConfig<I> info) {
        return new BaseDevice<>(
                info,
                this.networkFactory.getNetwork(this.extractNetworkConfig(info)),
                this.mapperFactory.getMappers(info)
        );
    }
}

public class DeviceFactoryManager<I> {
    private final Collection<DeviceFactory<I>> factories;
    // constructor

    public Device<I> createDevice(DeviceConfig<I> info) throws UnknowDeviceConfigException {
        for (DeviceFactory<I> factory : factories) {
            if (factory.canHandle(info)) {
                return factory.createDevice(info);
            }
        }
        throw new UnknownDeviceConfigException(info);
    }
}

public class MessageMapperManager<I> {
    private final Collection<MessageMapper<I, ? extends Message>> mappers;
    // constructor

    public Collection<MessageMapper<I, ? extends Message>> getMappers(DeviceConfig<I> info) {
        return mappers.stream()
                .filter(mapper -> mapper.canHandle(info))
                .toList();
    }
}

@AutoConfiguration
@EnableConfigurationProperties(DeviceProperties.class)
@ConditionalOnBooleanProperty(prefix = "spring", name = "device.enabled")
public class DeviceAutoConfiguration {

    @Bean
    @ConditionalOnBooleanProperty(prefix = "spring.device.network.default", value = "ftp.enabled", matchIfMissing = true)
    @ConditionalOnMissingBean(FtpNetworkFactory.class)
    public NetworkFactory ftpNetworkFactory(DeviceProperties properties) {
        return new DefaultFtpNetworkFactory();
    }

    @Bean
    @ConditionalOnBooleanProperty(prefix = "spring.device.network.default", value = "socket.enabled", matchIfMissing = true)
    @ConditionalOnMissingBean(SocketNetworkFactory.class)
    public NetworkFactory socketNetworkFactory(DeviceProperties properties) {
        return new DefaultSocketNetworkFactory();
    }

    @Bean
    @ConditionalOnBooleanProperty(prefix = "spring.device.network.default", value = "http.enabled", matchIfMissing = true)
    @ConditionalOnMissingBean(HttpNetworkFactory.class)
    public NetworkFactory httpNetworkFactory(DeviceProperties properties) {
        return new DefaultHttpNetworkFactory();
    }

    /**
     * @param mappers все, определённые пользователем конвертеры для всех моделей весов
     */
    @Bean
    private <I> MessageMapperManager<I> messageMapperFactory(Collection<MessageMapper<I, ? extends Message>> mappers) {
        return new MessageMapperManager<>(mappers);
    }

    /**
     * @param factories фабрики соединений (default и пользовательские)
     */
    @Bean
    public NetworkFactoryManager networkFactoryManager(Collection<NetworkFactory> factories) {
              return new NetworkFactoryManager(factories);
    }

    /**
     * @param factories фабрики весов (default и пользовательские)
     */
    @Bean
    public <I> DeviceFactoryManager<I> DeviceFactoryManager(Collection<DeviceFactory<I>> factories) {
        return new DeviceFactoryManager<>(factories);
    }