Партийное задание с использованием пружинного пакета @5 не запускается с помощью @scheduledanted Annotation ⇐ JAVA

[Anonymous]

Я пытаюсь реализовать запланированное партийное задание с помощью Spring-Batch@Last и Scheduler@Last.

Код: Выделить всё

import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.my.app.internal.api.batch.service.EmployeeService;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
@EnableScheduling
@RequiredArgsConstructor
public class ScheduledBatchTrigger {

private final EmployeeSaveJobConfig employeeSaveJobConfig;

@Scheduled(cron = "0 */15 * * * *")
public void triggerScheduledBatch() {
log.warn("Scheduled batch triggered");
try {
employeeSaveJobConfig.jobSaveEmployee();
} catch (Exception e) {
log.warn("Error Occurred during batch trigger: {}", e.getMessage());
log.error(e.getMessage());
}
log.warn("Scheduled batch ended");
}
}
< /code>
Код выше распечатывает < /p>
Scheduled batch triggered
Scheduled batch ended
< /code>
Но нет признаков выполнения для сотрудников avehibconfig.jobsaveemployee () < /code> метод,
, даже если я помещаю много регистраторов в метод.  < /p>
Я что -то упускаю?import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.repeat.RepeatStatus;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.PlatformTransactionManager;

import com.my.app.internal.api.batch.service.EmployeeService;
import com.my.domain.rdbs.domain.user.Employee;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Configuration
@RequiredArgsConstructor
public class EmployeeSaveJobConfig {

private final JobRepository jobRepository;
private final EmployeeService employeeService;
private final PlatformTransactionManager transactionManager;

@Bean
public Job jobSaveEmployee() {
log.warn("Starting job save employee job");
return new JobBuilder("EMPLOYEE_SAVE_JOB", jobRepository)
.incrementer(new RunIdIncrementer())
.start(employeeSaveStep())
.build();
}

@Bean
public Step employeeSaveStep() {
return new StepBuilder("EMPLOYEE_SAVE_JOB-step", jobRepository)
.tasklet((contribution, chunkContext) -> {
log.warn(employeeService.saveEmployee());
return RepeatStatus.FINISHED;
}, transactionManager)
.build();
}
}
< /code>
Job < /p>
import java.io.IOException;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.LocalDateTime;
import java.util.Optional;
import java.util.Set;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.my.domain.rdbs.domain.user.Employee;
import com.my.domain.rdbs.repository.EmployeeRepository;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
@RequiredArgsConstructor
public class EmployeeService {

private final EmployeeRepository employeeRepository;

@Value("${spring.profiles.active}")
private String activeProfile;

@Value("${employee.regular.identification-id}")
private Set regularIdSet;

private JsonNode fetchDataFromDataBase(String accessToken) throws JsonProcessingException {
final HttpResponse response;
try (HttpClient client = HttpClient.newHttpClient()) {
final HttpRequest request =
HttpRequest.newBuilder()
.uri(URI.create("https://api.employee.com/v1/persons"))
.header("Authorization", "Bearer "  + accessToken)
.build();
response = client.send(request, HttpResponse.BodyHandlers.ofString());
} catch (IOException | InterruptedException e) {
throw new RuntimeException(e);
}

final ObjectMapper mapper = new ObjectMapper();
return mapper.readTree(response.body());
}

private Employee collectRequiredData(String rawData) throws JsonProcessingException {
final ObjectMapper mapper = new ObjectMapper();
final JsonNode jsonData = mapper.readTree(rawData);
final String identificationId = jsonData.get("identificationId").textValue();
return Employee.builder()
.personId(jsonData.get("personId").textValue())
.account(jsonData.get("account").textValue())
.mailAddress(jsonData.get("mailaddress").textValue())
.identificationId(identificationId)
.regularEmployee(isUserRegularEmployee(identificationId))
.updatedAt(LocalDateTime.now())
.build();
}

public String saveEmployee() throws Exception {
String accessToken = "";
if (!"local".equals(activeProfile)) {
accessToken = fetchTokenFrom();
}

final JsonNode jsonData = fetchDataFromDataBase(accessToken);
if (jsonData.isArray()) {
for (JsonNode json : jsonData) {
final Employee currentEmployee = collectRequiredData(json.toString());
currentEmployee.setRegularEmployee(isUserRegularEmployee(currentEmployee.getPersonId()));
Optional.of(
employeeRepository.findByPersonId(json.get("personId").textValue())
.map(existingEmployee -> {
existingEmployee.setAccount(json.get("account").textValue());
existingEmployee.setMailAddress(json.get("mailaddress").textValue());
existingEmployee.setRegularEmployee(isUserRegularEmployee(existingEmployee.getPersonId()));
existingEmployee.setUpdatedAt(LocalDateTime.now());
return employeeRepository.save(existingEmployee);
}))
.orElseGet(() -> {
return Optional.ofNullable(employeeRepository.save(currentEmployee));
});
}
}
return "Finished!";
}

public boolean isUserRegularEmployee(String personId) {
final Optional employee = employeeRepository.findByPersonId(personId);

if (employee.isPresent()) {
return regularIdSet.contains(employee.get().getIdentificationId());
} else {
return false;
}
}

}
< /code>
service < /p>
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

import com.my.app.internal.api.batch.service.EmployeeService;

import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Component
@EnableScheduling
@RequiredArgsConstructor
public class ScheduledBatchTrigger {

private final EmployeeService employeeService;

@Scheduled(cron = "0 */15 * * * *")
public void triggerScheduledBatch() {
log.warn("Scheduled batch triggered");
try {
employeeService.saveEmployee();
} catch (Exception e) {
log.warn("Error Occurred during batch trigger: {}", e.getMessage());
log.error(e.getMessage());
}
log.warn("Scheduled batch ended");
}
}

Этот код запускает метод сотрудников.>

Подробнее здесь: https://stackoverflow.com/questions/797 ... annotation