스프링 배치-퀵 가이드
Batch processing사용자 상호 작용없이 일련의 자동화 된 복잡한 작업을 실행하는 처리 모드입니다. 일괄 프로세스는 대량 데이터를 처리하고 오랫동안 실행됩니다.
여러 엔터프라이즈 애플리케이션은 다음과 관련된 작업을 수행하기 위해 방대한 데이터를 처리해야합니다.
주기적 계산과 같은 시간 기반 이벤트.
대규모 데이터 세트에 대해 반복적으로 처리되는 주기적 애플리케이션.
트랜잭션 방식으로 사용 가능한 데이터의 처리 및 유효성 검사를 처리하는 응용 프로그램입니다.
따라서 이러한 트랜잭션을 수행하기 위해 엔터프라이즈 응용 프로그램에서 일괄 처리가 사용됩니다.
스프링 배치 란?
봄 배치는 lightweight framework 개발에 사용되는 Batch Applications 엔터프라이즈 애플리케이션에서 사용되는
대량 처리 외에도이 프레임 워크는 다음에 대한 기능을 제공합니다.
- 로깅 및 추적 포함
- 거래 관리
- 작업 처리 통계
- 작업 다시 시작
- 건너 뛰기 및 리소스 관리
분할 기술을 사용하여 스프링 배치 애플리케이션을 확장 할 수도 있습니다.
Spring Batch의 특징
다음은 Spring Batch의 주목할만한 기능입니다-
Flexibility− Spring Batch 애플리케이션은 유연합니다. 응용 프로그램에서 처리 순서를 변경하려면 XML 파일을 변경하기 만하면됩니다.
Maintainability− Spring Batch 애플리케이션은 유지 관리가 쉽습니다. Spring Batch 작업에는 단계가 포함되며 각 단계는 다른 단계에 영향을주지 않고 분리, 테스트 및 업데이트 할 수 있습니다.
Scalability− 분할 기술을 사용하여 Spring Batch 애플리케이션을 확장 할 수 있습니다. 이러한 기술을 사용하면-
작업 단계를 병렬로 실행합니다.
단일 스레드를 병렬로 실행합니다.
Reliability − 오류가 발생한 경우 단계를 분리하여 중지 된 위치에서 작업을 다시 시작할 수 있습니다.
Support for multiple file formats − Spring Batch는 XML, 플랫 파일, CSV, MYSQL, Hibernate, JDBC, Mongo, Neo4j 등과 같은 대규모 리더 및 작성자를 지원합니다.
Multiple ways to launch a job − 웹 애플리케이션, Java 프로그램, 명령 줄 등을 사용하여 Spring Batch 작업을 시작할 수 있습니다.
이 외에도 Spring Batch 애플리케이션은 다음을 지원합니다.
실패 후 자동 재시도.
배치 실행 중 및 배치 처리 완료 후 상태 및 통계 추적.
동시 작업을 실행합니다.
로깅, 리소스 관리, 건너 뛰기 및 처리 다시 시작과 같은 서비스.
이 장에서는 Eclipse IDE에서 Spring Batch 환경을 설정하는 방법을 설명합니다. 설치를 진행하기 전에 시스템에 Eclipse를 설치했는지 확인하십시오. 그렇지 않은 경우 시스템에 Eclipse를 다운로드하여 설치하십시오.
Eclipse에 대한 자세한 내용은 Eclipse Tutorial을 참조하십시오 .
Eclipse에서 Spring Batch 설정
Eclipse에서 Spring Batch 환경을 설정하려면 아래 단계를 따르십시오.
Step 1 − 다음 스크린 샷과 같이 Eclipse를 설치하고 새 프로젝트를 엽니 다.
Step 2 − 아래와 같이 Sample Spring Batch 프로젝트를 생성합니다.
Step 3− 프로젝트를 마우스 오른쪽 버튼으로 클릭하고 아래와 같이 Maven 프로젝트로 변환합니다. Maven 프로젝트로 변환하면Pom.xml필요한 종속성을 언급해야합니다. 그 후jar 이러한 파일은 프로젝트에 자동으로 다운로드됩니다.
Step 4 − 이제 pom.xml 프로젝트의 다음 내용 (스프링 배치 적용에 대한 종속성)을 복사하여 붙여넣고 프로젝트를 새로 고칩니다.
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>SpringBatchSample</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>SpringBatchExample</name>
<url>http://maven.apache.org</url>
<properties>
<jdk.version>1.8</jdk.version>
<spring.version>4.3.8.RELEASE</spring.version>
<spring.batch.version>3.0.7.RELEASE</spring.batch.version>
<mysql.driver.version>5.1.25</mysql.driver.version>
<junit.version>4.11</junit.version>
</properties>
<dependencies>
<!-- Spring Core -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version> </dependency> <!-- Spring jdbc, for database --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-jdbc</artifactId> <version>${spring.version}</version>
</dependency>
<!-- Spring XML to/back object -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-oxm</artifactId>
<version>${spring.version}</version> </dependency> <!-- MySQL database driver --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> <version>${mysql.driver.version}</version>
</dependency>
<!-- Spring Batch dependencies -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-core</artifactId>
<version>${spring.batch.version}</version> </dependency> <dependency> <groupId>org.springframework.batch</groupId> <artifactId>spring-batch-infrastructure</artifactId> <version>${spring.batch.version}</version>
</dependency>
<!-- Spring Batch unit test -->
<dependency>
<groupId>org.springframework.batch</groupId>
<artifactId>spring-batch-test</artifactId>
<version>${spring.batch.version}</version> </dependency> <!-- Junit --> <dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>${junit.version}</version>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<finalName>spring-batch</finalName>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-eclipse-plugin</artifactId>
<version>2.9</version>
<configuration>
<downloadSources>true</downloadSources>
<downloadJavadocs>false</downloadJavadocs>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.3.2</version>
<configuration>
<source>${jdk.version}</source> <target>${jdk.version}</target>
</configuration>
</plugin>
</plugins>
</build>
</project>마지막으로 Maven 종속성을 관찰하면 필요한 모든 jar 파일이 다운로드되었습니다.
다음은 Spring Batch 아키텍처의 다이어그램 표현입니다. 그림에 표시된 것처럼 아키텍처에는 세 가지 주요 구성 요소가 있습니다.Application, Batch Core, 및 Batch Infrastructure.
Application −이 컴포넌트는 Spring Batch 프레임 워크를 사용하여 작성한 모든 작업과 코드를 포함합니다.
Batch Core −이 구성 요소에는 배치 작업을 제어하고 시작하는 데 필요한 모든 API 클래스가 포함되어 있습니다.
Batch Infrastructure −이 구성 요소에는 응용 프로그램 및 Batch 핵심 구성 요소 모두에서 사용하는 리더, 작성자 및 서비스가 포함됩니다.
Spring Batch의 구성 요소
다음 그림은 Spring Batch의 다양한 구성 요소와 서로 연결되는 방식을 보여줍니다.
일
Spring Batch 애플리케이션에서 작업은 실행될 배치 프로세스입니다. 중단없이 처음부터 끝까지 실행됩니다. 이 작업은 단계로 더 나뉩니다 (또는 작업에 단계가 포함됨).
XML 파일 또는 Java 클래스를 사용하여 Spring Batch에서 작업을 구성합니다. 다음은 Spring Batch에서 Job의 XML 구성입니다.
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>배치 작업은 <job> </ job> 태그 내에 구성됩니다. 이름이 지정된 속성이 있습니다.id. 이러한 태그 내에서 단계의 정의와 순서를 정의합니다.
Restartable − 일반적으로 작업이 실행 중이고 다시 시작하려고 할 때 restart다시 시작됩니다. 이를 방지하려면restartable 가치 false 아래 그림과 같이.
<job id = "jobid" restartable = "false" >
</job>단계
ㅏ step 작업 (해당 부분)을 정의하고 실행하는 데 필요한 정보를 포함하는 작업의 독립적 인 부분입니다.
다이어그램에 지정된대로 각 단계는 ItemReader, ItemProcessor (선택 사항) 및 ItemWriter로 구성됩니다. A job may contain one or more steps.
독자, 작가 및 프로세서
안 item reader 특정 소스에서 Spring Batch 애플리케이션으로 데이터를 읽는 반면 item writer Spring Batch 애플리케이션의 데이터를 특정 대상에 씁니다.
안 Item processor스프링 배치로 읽은 데이터를 처리하는 처리 코드를 포함하는 클래스입니다. 응용 프로그램이 읽는 경우"n" 그러면 프로세서의 코드가 각 레코드에서 실행됩니다.
독자와 작가가 주어지지 않으면 taskletSpringBatch의 프로세서 역할을합니다. 단일 작업 만 처리합니다. 예를 들어, MySQL 데이터베이스에서 데이터를 읽고 처리하고 파일 (플랫)에 쓰는 간단한 단계로 작업을 작성하는 경우 다음 단계를 사용합니다.
ㅏ reader MySQL 데이터베이스에서 읽습니다.
ㅏ writer 플랫 파일에 기록합니다.
ㅏ custom processor 우리가 원하는대로 데이터를 처리합니다.
<job id = "helloWorldJob">
<step id = "step1">
<tasklet>
<chunk reader = "mysqlReader" writer = "fileWriter"
processor = "CustomitemProcessor" ></chunk>
</tasklet>
</step>
</ job>Spring Batch는 긴 목록을 제공합니다. readers 과 writers. 이러한 사전 정의 된 클래스를 사용하여 이에 대한 빈을 정의 할 수 있습니다. 우리는 논의 할 것이다readers 과 writers 다음 장에서 자세히 설명합니다.
JobRepository
Spring Batch의 Job 저장소는 JobLauncher, Job 및 Step 구현을위한 CRUD (Create, Retrieve, Update 및 Delete) 작업을 제공합니다. 아래와 같이 XML 파일에 작업 저장소를 정의합니다.
<job-repository id = "jobRepository"/>이외에 id, 더 많은 옵션 (선택 사항)을 사용할 수 있습니다. 다음은 모든 옵션과 기본값이있는 작업 저장소의 구성입니다.
<job-repository id = "jobRepository"
data-source = "dataSource"
transaction-manager = "transactionManager"
isolation-level-for-create = "SERIALIZABLE"
table-prefix = "BATCH_"
max-varchar-length = "1000"/>In-Memory Repository − Spring Batch의 도메인 객체를 데이터베이스에 저장하지 않으려면 아래와 같이 jobRepository의 인 메모리 버전을 구성 할 수 있습니다.
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean ">
<property name = "transactionManager" ref = "transactionManager"/>
</bean>JobLauncher
JobLauncher는 Spring Batch 작업을 given set of parameters. SampleJoblauncher 구현하는 클래스입니다 JobLauncher상호 작용. 다음은 JobLauncher의 구성입니다.
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>JobInstance
ㅏ JobInstance작업의 논리적 실행을 나타냅니다. 작업을 실행할 때 생성됩니다. 각 작업 인스턴스는 작업 이름과 실행 중에 전달되는 매개 변수로 구분됩니다.
JobInstance 실행이 실패하면 동일한 JobInstance를 다시 실행할 수 있습니다. 따라서 각 JobInstance는 여러 작업 실행을 가질 수 있습니다.
JobExecution 및 StepExecution
JobExecution 및 StepExecution은 작업 / 단계의 실행을 나타냅니다. 여기에는 시작 시간 (작업 / 단계), 종료 시간 (작업 / 단계)과 같은 작업 / 단계의 실행 정보가 포함됩니다.
이 튜토리얼의 거의 모든 예제에는 다음 파일이 포함되어 있습니다.
- 구성 파일 (XML 파일)
- Tasklet / 프로세서 (Java 클래스)
- setter 및 getter가있는 Java 클래스 (Java 클래스 (Bean))
- Mapper 클래스 (Java 클래스)
- Launcher 클래스 (Java 클래스)
구성 파일
구성 파일 (XML)에는 다음이 포함됩니다.
그만큼 job 과 step 정의.
정의하는 콩 readers 과 writers.
JobLauncher, JobRepository, Transaction Manager 및 데이터 소스와 같은 구성 요소의 정의.
우리의 예에서는 더 나은 이해를 위해 이것을 두 개의 파일로 나누었습니다. job.xml 파일 (작업, 단계, 리더 및 작성기 정의) 및 context.xml 파일 (작업 실행기, 작업 저장소, 트랜잭션 관리자 및 데이터 소스).
매퍼 클래스
Mapper 클래스는 독자에 따라 다음과 같은 인터페이스를 구현합니다. row mapper, field set mapper등. 리더에서 데이터를 가져 와서 Java 클래스로 설정하는 코드가 포함되어 있습니다. setter 과 getter 메소드 (Java Bean).
자바 빈 클래스
Java 클래스 setters 과 getters(Java bean)은 여러 값을 가진 데이터를 나타냅니다. 도우미 클래스 역할을합니다. 한 컴포넌트 (reader, writer, processer)의 데이터를이 클래스의 객체 형태로 다른 컴포넌트로 전달합니다.
Tasklet / 프로세서
Tasklet / 프로세서 클래스는 Spring Batch 애플리케이션의 처리 코드를 포함합니다. 프로세서는 읽은 데이터를 포함하는 객체를 받아 처리하고 처리 된 데이터를 반환하는 클래스입니다 (형식 객체).
런처 클래스
이 클래스 (App.java)에는 Spring Batch 애플리케이션을 시작하는 코드가 포함되어 있습니다.
Spring Batch 애플리케이션을 작성하는 동안 Spring Batch 네임 스페이스에 제공된 XML 태그를 사용하여 작업, 단계, JobLauncher, JobRepository, Transaction Manager, 리더 및 작성자를 구성합니다. 따라서 아래와 같이 XML 파일에이 네임 스페이스를 포함해야합니다.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/bean
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">다음 섹션에서는 Spring Batch 네임 스페이스에서 사용할 수있는 다양한 태그, 속성 및 예제에 대해 설명합니다.
일
이 태그는 SpringBatch의 작업을 정의 / 구성하는 데 사용됩니다. 여기에는 일련의 단계가 포함되어 있으며 JobLauncher를 사용하여 시작할 수 있습니다.
이 태그에는 아래에 나열된 2 개의 속성이 있습니다.
| S. 아니 | 속성 및 설명 |
|---|---|
| 1 | Id 작업의 ID이며이 속성에 값을 지정해야합니다. |
| 2 | restartable 작업을 다시 시작할 수 있는지 여부를 지정하는 데 사용되는 속성입니다. 이 속성은 선택 사항입니다. |
다음은 SpringBatch 작업의 XML 구성입니다.
<job id = "jobid" restartable = "false" >
. . . . . . . .
. . . . . . . .
. . . . . . . . // Step definitions
</job>단계
이 태그는 SpringBatch 작업의 단계를 정의 / 구성하는 데 사용됩니다. 그것은 다음 세 가지 속성을 가지고 있습니다-
| S. 아니 | 속성 및 설명 |
|---|---|
| 1 | Id 작업의 ID이며이 속성에 값을 지정해야합니다. |
| 2 | next 다음 단계를 지정하는 바로 가기입니다. |
| 삼 | parent 구성이 상속해야하는 상위 Bean의 이름을 지정하는 데 사용됩니다. |
다음은 SpringBatch 단계의 XML 구성입니다.
<job id = "jobid">
<step id = "step1" next = "step2"/>
<step id = "step2" next = "step3"/>
<step id = "step3"/>
</job>큰 덩어리
이 태그는 청크를 정의 / 구성하는 데 사용됩니다. tasklet. 그것은 다음 네 가지 속성을 가지고 있습니다-
| S. 아니 | 속성 및 설명 |
|---|---|
| 1 | reader 항목 판독기 Bean의 이름을 나타냅니다. 유형의 값을 허용합니다.org.springframework.batch.item.ItemReader. |
| 2 | writer 항목 판독기 Bean의 이름을 나타냅니다. 유형의 값을 허용합니다.org.springframework.batch.item.ItemWriter. |
| 삼 | processor 항목 판독기 Bean의 이름을 나타냅니다. 유형의 값을 허용합니다.org.springframework.batch.item.ItemProcessor. |
| 4 | commit-interval 트랜잭션을 커밋하기 전에 처리 할 항목 수를 지정하는 데 사용됩니다. |
다음은 SpringBatch 청크의 XML 구성입니다.
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>JobRepository
JobRepository Bean은 관계형 데이터베이스를 사용하여 JobRepository를 구성하는 데 사용됩니다. 이 Bean은 유형의 클래스와 연관됩니다.org.springframework.batch.core.repository.JobRepository.
| S. 아니 | 속성 및 설명 |
|---|---|
| 1 | dataSource 데이터 소스를 정의하는 Bean 이름을 지정하는 데 사용됩니다. |
| 2 | transactionManager transactionmanager를 정의하는 Bean의 이름을 지정하는 데 사용됩니다. |
| 삼 | databaseType 작업 저장소에서 사용되는 관계형 데이터베이스의 유형을 지정합니다. |
다음은 JobRepository의 구성 예입니다.
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref="transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>JobLauncher
JobLauncher Bean은 JobLauncher를 구성하는 데 사용됩니다. 클래스와 연결되어 있습니다.org.springframework.batch.core.launch.support.SimpleJobLauncher(우리 프로그램에서). 이 Bean에는jobrepository을 정의하는 Bean의 이름을 지정하는 데 사용됩니다. jobrepository.
다음은 jobLauncher의 구성 예입니다.
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>TransactionManager
TransactionManager 빈은 관계형 데이터베이스를 사용하여 TransactionManager를 구성하는 데 사용됩니다. 이 Bean은 유형의 클래스와 연관됩니다.org.springframework.transaction.platform.TransactionManager.
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />데이터 소스
데이터 소스 Bean은 다음을 구성하는 데 사용됩니다. Datasource. 이 Bean은 유형의 클래스와 연관됩니다.org.springframework.jdbc.datasource.DriverManagerDataSource.
| S. 아니 | 속성 및 설명 |
|---|---|
| 1 | driverClassName 데이터베이스에 연결하는 데 사용되는 드라이버의 클래스 이름을 지정합니다. |
| 2 | url 이것은 데이터베이스의 URL을 지정합니다. |
| 삼 | username 데이터베이스에 연결할 사용자 이름을 지정합니다. |
| 4 | password 데이터베이스에 연결할 암호를 지정합니다. |
다음은 datasource.
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>안 Item Reader 특정 소스에서 스프링 배치 애플리케이션으로 데이터를 읽는 반면 Item Writer Spring Batch 애플리케이션의 데이터를 특정 대상에 씁니다.
안 Item processor스프링 배치로 읽은 데이터를 처리하는 처리 코드를 포함하는 클래스입니다. 애플리케이션이 n 개의 레코드를 읽으면 프로세서의 코드가 각 레코드에서 실행됩니다.
ㅏ chunk 의 하위 요소입니다. tasklet. 읽기, 쓰기 및 처리 작업을 수행하는 데 사용됩니다. 아래와 같이 단계 내에서이 요소를 사용하여 리더, 라이터 및 프로세서를 구성 할 수 있습니다.
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>Spring Batch는 MongoDB, Neo4j, MySQL, XML, flatfile, CSV 등과 같은 다양한 파일 시스템 / 데이터베이스에서 데이터를 읽고 쓸 수있는 리더와 작성자를 제공합니다.
애플리케이션에 리더를 포함하려면 해당 리더에 대한 Bean을 정의하고 Bean 내의 모든 필수 특성에 값을 제공하고 id 청크 요소의 속성에 대한 값과 같은 빈의 reader (동일 writer).
ItemReader
데이터를 읽는 단계 (일괄 처리)의 엔티티입니다. ItemReader는 한 번에 한 항목을 읽습니다. Spring Batch는 인터페이스를 제공합니다ItemReader. 모든readers 이 인터페이스를 구현하십시오.
다음은 다양한 소스에서 읽기 위해 Spring Batch에서 제공하는 미리 정의 된 ItemReader 클래스의 일부입니다.
| 리더 | 목적 |
|---|---|
| FlatFIleItemReader | 플랫 파일에서 데이터를 읽습니다. |
| StaxEventItemReader | XML 파일에서 데이터를 읽으려면. |
| StoredProcedureItemReader | 데이터베이스의 저장 프로 시저에서 데이터를 읽으려면 |
| JDBCPagingItemReader | 관계형 데이터베이스 데이터베이스에서 데이터를 읽습니다. |
| MongoItemReader | MongoDB에서 데이터를 읽으려면. |
| Neo4jItemReader | Neo4jItemReader에서 데이터를 읽으려면. |
우리는 구성해야 ItemReaders콩을 만들어요. 다음은StaxEventItemReader XML 파일에서 데이터를 읽습니다.
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/userss.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>관찰 된대로 구성하는 동안 필요한 판독기의 각 클래스 이름을 지정해야하며 필요한 모든 속성에 값을 제공해야합니다.
ItemWriter
그것은의 요소입니다 step데이터를 쓰는 일괄 프로세스의. ItemWriter는 한 번에 하나의 항목을 씁니다. Spring Batch는 인터페이스를 제공합니다ItemWriter. 모든 작성자가이 인터페이스를 구현합니다.
다음은 다양한 소스에서 읽을 수 있도록 Spring Batch에서 제공하는 미리 정의 된 ItemWriter 클래스 중 일부입니다.
| 작가 | 목적 |
|---|---|
| FlatFIleItemWriter | 플랫 파일에 데이터를 기록합니다. |
| StaxEventItemWriter | XML 파일에 데이터 쓰기. |
| StoredProcedureItemWriter | 데이터베이스의 저장 프로 시저에 데이터를 기록합니다. |
| JDBCPagingItemWriter | 관계형 데이터베이스 데이터베이스에 데이터를 기록합니다. |
| MongoItemWriter | MongoDB에 데이터 쓰기. |
| Neo4jItemWriter | Neo4j에 데이터 쓰기. |
같은 방식으로 빈을 생성하여 ItemWriter를 구성해야합니다. 다음은JdbcCursorItemReader MySQL 데이터베이스에 데이터를 씁니다.
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>아이템 프로세서
ItemProcessor: ItemProcessor는 데이터를 처리하는 데 사용됩니다. 주어진 항목이 유효하지 않으면 반환null그렇지 않으면 주어진 항목을 처리하고 처리 된 결과를 반환합니다. 인터페이스ItemProcessor<I,O> 프로세서를 나타냅니다.
Tasklet class − 아니요 reader 과 writer주어진 경우 Tasklet은 SpringBatch의 프로세서 역할을합니다. 단일 작업 만 처리합니다.
인터페이스를 구현하여 커스텀 아이템 프로세서를 정의 할 수 있습니다. ItemProcessor 패키지의 org.springframework.batch.item.ItemProcessor. 이 ItemProcessor 클래스는 개체를 받아 데이터를 처리하고 처리 된 데이터를 다른 개체로 반환합니다.
배치 프로세스에서 "n"레코드 또는 데이터 요소를 읽은 다음 각 레코드에 대해 데이터를 읽고 처리하고 기록기에 데이터를 씁니다. 데이터를 처리하기 위해 전달 된 프로세서에서 릴레이합니다.
예를 들어, 특정 PDF 문서를로드하고, 새 페이지를 만들고, 데이터 항목을 표 형식으로 PDF에 쓰는 코드를 작성했다고 가정 해 보겠습니다. 이 응용 프로그램을 실행하면 XML 문서에서 모든 데이터 항목을 읽고 MySQL 데이터베이스에 저장하고 개별 페이지의 지정된 PDF 문서에 인쇄합니다.
예
다음은 샘플 ItemProcessor 클래스입니다.
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}이 장에서는 기본적인 Spring Batch 애플리케이션을 보여줍니다. 단순히tasklet 메시지를 표시합니다.
Spring Batch 애플리케이션에는 다음 파일이 포함되어 있습니다.
Configuration file− 이것은 작업과 작업 단계를 정의하는 XML 파일입니다. (응용 프로그램에 독자와 작성자도 포함되는 경우readers 과 writers 이 파일에도 포함되어 있습니다.)
Context.xml −이 파일에서는 작업 저장소, 작업 실행기 및 트랜잭션 관리자와 같은 빈을 정의합니다.
Tasklet class −이 수업에서는 처리 코드 작업을 작성합니다 (이 경우 간단한 메시지 표시)
Launcher class −이 수업에서는 Job launcher를 실행하여 Batch Application을 실행합니다.
jobConfig.xml
다음은 샘플 Spring Batch 애플리케이션의 구성 파일입니다.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd ">
<import resource="context.xml" />
<!-- Defining a bean -->
<bean id = "tasklet" class = "a_sample.MyTasklet" />
<!-- Defining a job-->
<batch:job id = "helloWorldJob">
<!-- Defining a Step -->
<batch:step id = "step1">
<tasklet ref = "tasklet"/>
</batch:step>
</batch:job>
</beans>Context.xml
다음은 context.xml Spring Batch 애플리케이션의.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<bean id = "jobRepository"
class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean">
<property name = "transactionManager" ref = "transactionManager" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
</beans>Tasklet.java
다음은 간단한 메시지를 표시하는 Tasklet 클래스입니다.
import org.springframework.batch.core.StepContribution;
import org.springframework.batch.core.scope.context.ChunkContext;
import org.springframework.batch.core.step.tasklet.Tasklet;
import org.springframework.batch.repeat.RepeatStatus;
public class MyTasklet implements Tasklet {
@Override
public RepeatStatus execute(StepContribution arg0, ChunkContext arg1) throws Exception {
System.out.println("Hello This is a sample example of spring batch");
return RepeatStatus.FINISHED;
}
}App.java
다음은 일괄 처리를 시작하는 코드입니다.
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args)throws Exception {
// System.out.println("hello");
String[] springConfig = {"a_sample/job_hello_world.xml"};
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}실행시 위의 SpringBatch 프로그램은 다음과 같은 출력을 생성합니다.
Apr 24, 2017 4:40:54 PM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO:Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@2ef1e4fa: startup date [Mon Apr 24 16:40:54 IST 2017]; root of context hierarchy
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions
Apr 24, 2017 4:40:54 PM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher afterPropertiesSet
INFO: No TaskExecutor has been set, defaulting to synchronous executor.
Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run INFO: Job: [FlowJob: [name=helloWorldJob]] launched with the following parameters: [{}] Apr 24, 2017 4:40:55 PM org.springframework.batch.core.job.SimpleStepHandler handleStep INFO: Executing step: [step1] Hello This is a sample example of spring batch Apr 24, 2017 4:40:55 PM org.springframework.batch.core.launch.support.SimpleJobLauncher$1 run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}] and the following status: [COMPLETED]
Exit Status : COMPLETED이 장에서는 XML 리더와 MySQL Writer를 사용하는 Spring Batch 애플리케이션을 만들 것입니다.
Reader − 응용 프로그램에서 사용하는 리더는 StaxEventItemReader XML 문서에서 데이터를 읽습니다.
다음은이 애플리케이션에서 사용하는 입력 XML 문서입니다. 이 문서에는 자습서 ID, 자습서 작성자, 자습서 제목, 제출 날짜, 자습서 아이콘 및 자습서 설명과 같은 세부 정보를 지정하는 데이터 레코드가 있습니다.
<?xml version="1.0" encoding="UTF-8"?>
<tutorials>
<tutorial>
<tutorial_id>1001</tutorial_id>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
<submission_date>06-05-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/java/images/java-minilogo.jpg</tutorial_icon>
<tutorial_description>Java is a high-level programming language originally
developed by Sun Microsystems and released in 1995.
Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1002</tutorial_id>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
<submission_date>19-04-2007</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/mysql/images/mysql-minilogo.jpg</tutorial_icon>
<tutorial_description>MySQL is the most popular
Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL
and make you comfortable with MySQL programming.</tutorial_description>
</tutorial>
<tutorial>
<tutorial_id>1003</tutorial_id>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
<submission_date>06-07-2017</submission_date>
<tutorial_icon>https://www.tutorialspoint.com/javafx/images/javafx-minilogo.jpg</tutorial_icon>
<tutorial_description>JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX that are required
to develop effective Rich Internet Applications</tutorial_description>
</tutorial>
</tutorials>Writer − writer 우리는 응용 프로그램에서 사용하고 있습니다 JdbcBatchItemWriterMySQL 데이터베이스에 데이터를 씁니다. MySQL에서 다음과 같은 데이터베이스 내에 테이블을 만들었다 고 가정합니다."details".
CREATE TABLE details.TUTORIALS(
tutorial_id int(10) NOT NULL,
tutorial_author VARCHAR(20),
tutorial_title VARCHAR(50),
submission_date VARCHAR(20),
tutorial_icon VARCHAR(200),
tutorial_description VARCHAR(1000)
);Processor − 응용 프로그램에서 사용하는 프로세서는 PDF 문서에 각 레코드의 데이터를 기록하는 맞춤형 프로세서입니다.
일괄 처리에서 "n"레코드 또는 데이터 요소를 읽은 다음 각 레코드에 대해 데이터를 읽고 처리하고 Writer에 데이터를 씁니다. 데이터를 처리하기 위해 전달 된 프로세서에서 릴레이합니다. 이 경우 사용자 정의 프로세서 클래스에서 특정 PDF 문서를로드하고, 새 페이지를 만들고, 데이터 항목을 표 형식으로 PDF에 쓰는 코드를 작성했습니다.
마지막으로이 응용 프로그램을 실행하면 XML 문서에서 모든 데이터 항목을 읽고 MySQL 데이터베이스에 저장하고 개별 페이지의 지정된 PDF 문서에 인쇄합니다.
jobConfig.xml
다음은 샘플 Spring Batch 애플리케이션의 구성 파일입니다. 이 파일에서는 작업과 단계를 정의합니다. 이 외에도 ItemReader, ItemProcessor 및 ItemWriter에 대한 빈도 정의합니다. (여기서는 이들을 각각의 클래스와 연결하고 구성하는 데 필요한 속성의 값을 전달합니다.)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd ">
<import resource = "../jobs/context.xml" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "xmlItemReader" writer = "mysqlItemWriter" processor = "itemProcessor">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "xmlItemReader"
class = "org.springframework.batch.item.xml.StaxEventItemReader">
<property name = "fragmentRootElementName" value = "tutorial" />
<property name = "resource" value = "classpath:resources/tutorial.xml" />
<property name = "unmarshaller" ref = "customUnMarshaller" />
</bean>
<bean id = "customUnMarshaller" class = "org.springframework.oxm.xstream.XStreamMarshaller">
<property name = "aliases">
<util:map id = "aliases">
<entry key = "tutorial" value = "Tutorial" />
</util:map>
</property>
</bean>
<bean id = "mysqlItemWriter" class = "org.springframework.batch.item.database.JdbcBatchItemWriter">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql">
<value>
<![CDATA[insert into details.tutorials (tutorial_id, tutorial_author, tutorial_title,
submission_date, tutorial_icon, tutorial_description)
values (:tutorial_id, :tutorial_author, :tutorial_title, :submission_date,
:tutorial_icon, :tutorial_description);]]>
</value>
</property>
<property name = "itemSqlParameterSourceProvider">
<bean class = "org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider" />
</property>
</bean>
</beans>Context.xml
다음은 context.xmlSpring Batch 애플리케이션의. 이 파일에서는 작업 저장소, 작업 실행기 및 트랜잭션 관리자와 같은 빈을 정의합니다.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql"/>
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql"/>
</jdbc:initialize-database>
</beans>CustomItemProcessor.java
다음은 processor수업. 이 클래스에서는 애플리케이션에서 처리 코드를 작성합니다. 여기에서는 PDF 문서를로드하고, 새 페이지를 만들고, 테이블을 만들고, 각 레코드에 대해 자습서 ID, 자습서 이름, 작성자, 테이블에 제출 날짜를 삽입합니다.
import java.io.File;
import java.io.IOException;
import org.apache.pdfbox.pdmodel.PDDocument;
import org.apache.pdfbox.pdmodel.PDPage;
import org.apache.pdfbox.pdmodel.PDPageContentStream;
import org.apache.pdfbox.pdmodel.font.PDType1Font;
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
public static void drawTable(PDPage page, PDPageContentStream contentStream,
float y, float margin, String[][] content) throws IOException {
final int rows = content.length;
final int cols = content[0].length;
final float rowHeight = 50;
final float tableWidth = page.getMediaBox().getWidth()-(2*margin);
final float tableHeight = rowHeight * rows;
final float colWidth = tableWidth/(float)cols;
final float cellMargin=5f;
// draw the rows
float nexty = y ;
for (int i = 0; i <= rows; i++) {
contentStream.drawLine(margin,nexty,margin+tableWidth,nexty);
nexty-= rowHeight;
}
//draw the columns
float nextx = margin;
for (int i = 0; i <= cols; i++) {
contentStream.drawLine(nextx,y,nextx,y-tableHeight);
nextx += colWidth;
}
// now add the text
contentStream.setFont(PDType1Font.HELVETICA_BOLD,12);
float textx = margin+cellMargin;
float texty = y-15;
for(int i = 0; i < content.length; i++){
for(int j = 0 ; j < content[i].length; j++){
String text = content[i][j];
contentStream.beginText();
contentStream.moveTextPositionByAmount(textx,texty);
contentStream.drawString(text);
contentStream.endText();
textx += colWidth;
}
texty-=rowHeight;
textx = margin+cellMargin;
}
}
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
// Creating PDF document object
PDDocument doc = PDDocument.load(new File("C:/Examples/test.pdf"));
// Creating a blank page
PDPage page = new PDPage();
doc.addPage( page );
PDPageContentStream contentStream = new PDPageContentStream(doc, page);
String[][] content = {{"Id",""+item.getTutorial_id()},
{"Title", item.getTutorial_title()},
{"Authour", item.getTutorial_author()},
{"Submission Date", item.getSubmission_date()}} ;
drawTable(page, contentStream, 700, 100, content);
contentStream.close();
doc.save("C:/Examples/test.pdf" );
System.out.println("Hello");
return item;
}
}TutorialFieldSetMapper.java
다음은 Tutorial 클래스에 데이터를 설정하는 ReportFieldSetMapper 클래스입니다.
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
// instantiating the Tutorial class
Tutorial tutorial = new Tutorial();
// Setting the fields from XML
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_title(fieldSet.readString(1));
tutorial.setTutorial_author(fieldSet.readString(2));
tutorial.setTutorial_icon(fieldSet.readString(3));
tutorial.setTutorial_description(fieldSet.readString(4));
return tutorial;
}
}Tutorial.java
다음은 Tutorial수업. 간단한 수업입니다.setter 과 getter 행동 양식.
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
private String tutorial_icon;
private String tutorial_description;
@Override
public String toString() {
return " [id=" + tutorial_id + ", author=" + tutorial_author
+ ", title=" + tutorial_title + ", date=" + submission_date + ", icon ="
+tutorial_icon +", description = "+tutorial_description+"]";
}
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String getTutorial_icon() {
return tutorial_icon;
}
public void setTutorial_icon(String tutorial_icon) {
this.tutorial_icon = tutorial_icon;
}
public String getTutorial_description() {
return tutorial_description;
}
public void setTutorial_description(String tutorial_description) {
this.tutorial_description = tutorial_description;
}
}App.java
다음은 일괄 처리를 시작하는 코드입니다. 이 수업에서는 JobLauncher를 실행하여 배치 애플리케이션을 시작합니다.
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}이 응용 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.
May 05, 2017 4:39:22 PM org.springframework.context.support.ClassPathXmlApplicationContext
prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@306a30c7:
startup date [Fri May 05 16:39:22 IST 2017]; root of context hierarchy
May 05, 2017 4:39:23 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 05, 2017 4:39:32 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [id=1001, author=Sanjay, title=Learn Java, date=06-05-2007,
icon =https://www.tutorialspoint.com/java/images/java-mini-logo.jpg,
description = Java is a high-level programming language originally developed by Sun Microsystems
and released in 1995. Java runs on a variety of platforms.
This tutorial gives a complete understanding of Java.');]
Hello
Processing.. [id=1002, author=Abdul S, title=Learn MySQL, date=19-04-2007,
icon =https://www.tutorialspoint.com/mysql/images/mysql-mini-logo.jpg,
description = MySQL is the most popular Open Source Relational SQL database management system.
MySQL is one of the best RDBMS being used for developing web-based software applications.
This tutorial will give you quick start with MySQL and make you comfortable with MySQL programming.]
Hello
Processing... [id=1003, author=Krishna Kasyap, title=Learn JavaFX, date=06-072017,
icon =https://www.tutorialspoint.com/javafx/images/javafx-mini-logo.jpg,
description = JavaFX is a Java library used to build Rich Internet Applications.
The applications developed using JavaFX can run on various devices
such as Desktop Computers, Mobile Phones, TVs, Tablets, etc.
This tutorial, discusses all the necessary elements of JavaFX
that are required to develop effective Rich Internet Applications]
Hello
May 05, 2017 4:39:36 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters: [{}]
and the following status: [COMPLETED]
Exit Status : COMPLETED확인하는 경우 details.tutorial 데이터베이스의 테이블에 다음과 같은 출력이 표시됩니다.
| 튜토리얼 _id | 튜토리얼 _author | 튜토리얼 _title | 제출 날짜 | 튜토리얼 _icon | 튜토리얼 _description |
|---|---|---|---|---|---|
| 1001 | 산 제이 | 자바 배우기 | 2007 년 5 월 6 일 | https : //www.tutorials point.com / java / images / java-mini-logo.jpg | Java는 원래 Sun Microsystems에서 개발하여 1995 년에 출시 한 고급 프로그래밍 언어입니다. Java는 다양한 플랫폼에서 실행됩니다. 이 튜토리얼은 Java에 대한 완전한 이해를 제공합니다. |
| 1002 | 압둘 S | MySQL 배우기 | 2007 년 4 월 19 일 | https : // www. tutorialspoint.com / mysql / images /mysql-minilogo.jpg | MySQL은 가장 널리 사용되는 오픈 소스 관계형 SQL 데이터베이스 관리 시스템입니다. MySQL은 웹 기반 소프트웨어 애플리케이션을 개발하는 데 사용되는 최고의 RDBMS 중 하나입니다. 이 튜토리얼은 MySQL을 빠르게 시작하고 MySQL 프로그래밍에 익숙해 지도록합니다. |
| 1003 | JavaFX 알아보기 | 크리슈나 카삽 | 2017 년 7 월 6 일 | https : // www. tutorialspoint.com / javafx / images / javafx-minilogo.jpg | MySQL은 가장 널리 사용되는 오픈 소스 관계형 SQL 데이터베이스 관리 시스템입니다. MySQL은 웹 기반 소프트웨어 애플리케이션을 개발하는 데 사용되는 최고의 RDBMS 중 하나입니다. 이 튜토리얼은 MySQL을 빠르게 시작하고 MySQL 프로그래밍에 익숙해 지도록합니다. |
그러면 아래와 같이 각 페이지의 레코드가있는 PDF가 생성됩니다.
이 장에서는 CSV Reader와 XML Writer를 사용하는 간단한 Spring Batch 애플리케이션을 만들 것입니다.
Reader − reader 우리는 응용 프로그램에서 사용하고 있습니다 FlatFileItemReader CSV 파일에서 데이터를 읽습니다.
다음은이 애플리케이션에서 사용하는 입력 CSV 파일입니다. 이 문서에는 자습서 ID, 자습서 작성자, 자습서 제목, 제출 날짜, 자습서 아이콘 및 자습서 설명과 같은 세부 정보를 지정하는 데이터 레코드가 있습니다.
1001, "Sanjay", "Learn Java", 06/05/2007
1002, "Abdul S", "Learn MySQL", 19/04/2007
1003, "Krishna Kasyap", "Learn JavaFX", 06/07/2017Writer − 애플리케이션에서 사용하는 Writer는 StaxEventItemWriter XML 파일에 데이터를 씁니다.
Processor − 응용 프로그램에서 사용하는 프로세서는 CSV 파일에서 읽은 레코드 만 인쇄하는 사용자 지정 프로세서입니다.
jobConfig.xml
다음은 샘플 Spring Batch 애플리케이션의 구성 파일입니다. 이 파일에서는 작업과 단계를 정의합니다. 이 외에도 ItemReader, ItemProcessor 및 ItemWriter에 대한 빈도 정의합니다. (여기서 우리는 그것들을 각각의 클래스와 연관시키고 그것들을 구성하는 데 필요한 속성의 값을 전달합니다.)
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "cvsFileItemReader" writer = "xmlItemWriter"
processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "cvsFileItemReader"
class = "org.springframework.batch.item.file.FlatFileItemReader">
<property name = "resource" value = "classpath:resources/report.csv" />
<property name = "lineMapper">
<bean
class = "org.springframework.batch.item.file.mapping.DefaultLineMapper">
<property name = "lineTokenizer">
<bean
class = "org.springframework.batch.item.file.transform.DelimitedLineTokenizer">
<property name = "names" value = "tutorial_id,
tutorial_author, Tutorial_title, submission_date" />
</bean>
</property>
<property name = "fieldSetMapper">
<bean class = "ReportFieldSetMapper" />
</property>
</bean>
</property>
</bean>
<bean id = "xmlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "tutorials" />
</bean>
<bean id = "reportMarshaller"
class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>Context.xml
다음은 context.xmlSpring Batch 애플리케이션의. 이 파일에서는 작업 저장소, 작업 실행기 및 트랜잭션 관리자와 같은 빈을 정의합니다.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<bean id = "dataSource" class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>CustomItemProcessor.java
다음은 프로세서 클래스입니다. 이 클래스에서는 애플리케이션에서 처리 코드를 작성합니다. 여기에서는 각 레코드의 내용을 인쇄합니다.
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}TutorialFieldSetMapper.java
다음은 Tutorial 클래스에 데이터를 설정하는 TutorialFieldSetMapper 클래스입니다.
import org.springframework.batch.item.file.mapping.FieldSetMapper;
import org.springframework.batch.item.file.transform.FieldSet;
import org.springframework.validation.BindException;
public class TutorialFieldSetMapper implements FieldSetMapper<Tutorial> {
@Override
public Tutorial mapFieldSet(FieldSet fieldSet) throws BindException {
//Instantiating the report object
Tutorial tutorial = new Tutorial();
//Setting the fields
tutorial.setTutorial_id(fieldSet.readInt(0));
tutorial.setTutorial_author(fieldSet.readString(1));
tutorial.setTutorial_title(fieldSet.readString(2));
tutorial.setSubmission_date(fieldSet.readString(3));
return tutorial;
}
}Tutorial.java 클래스
다음은 Tutorial수업. 다음과 같은 간단한 Java 클래스입니다.setter 과 getter행동 양식. 이 클래스에서는 주석을 사용하여이 클래스의 메서드를 XML 파일의 태그와 연결합니다.
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "tutorial")
public class Tutorial {
private int tutorial_id;
private String tutorial_author;
private String tutorial_title;
private String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [Tutorial id=" + tutorial_id + ",
Tutorial Author=" + tutorial_author + ",
Tutorial Title=" + tutorial_title + ",
Submission Date=" + submission_date + "]";
}
}App.java
다음은 일괄 처리를 시작하는 코드입니다. 이 수업에서는 JobLauncher를 실행하여 배치 애플리케이션을 시작합니다.
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}이 응용 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.
May 08, 2017 10:10:12 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing
org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37: startup date
[Mon May 08 10:10:12 IST 2017]; root of context hierarchy
May 08, 2017 10:10:12 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 10:10:15 AM org.springframework.jdbc.datasource.init.ScriptUtils executeSqlScript
INFO: Executing step: [step1]
Processing... [Tutorial id=1001, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06/05/2007]
Processing... [Tutorial id=1002, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19/04/2007]
Processing... [Tutorial id=1003, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06/07/2017]
May 08, 2017 10:10:21 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED그러면 다음 내용이 포함 된 XML 파일이 생성됩니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<tutorials>
<tutorial tutorial_id = "1001">
<submission_date>06/05/2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1002">
<submission_date>19/04/2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</tutorial>
<tutorial tutorial_id = "1003">
<submission_date>06/07/2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</tutorial>
</tutorials>이 장에서는 MySQL 리더와 XML Writer를 사용하는 Spring Batch 애플리케이션을 만들 것입니다.
Reader − 응용 프로그램에서 사용하는 리더는 JdbcCursorItemReader MySQL 데이터베이스에서 데이터를 읽습니다.
아래와 같이 MySQL 데이터베이스에 테이블을 생성했다고 가정합니다.
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);여기에 다음 레코드를 삽입했다고 가정합니다.
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)Writer − 애플리케이션에서 사용하는 Writer는 StaxEventItemWriter XML 파일에 데이터를 씁니다.
Processor − 응용 프로그램에서 사용하는 프로세서는 CSV 파일에서 읽은 레코드 만 인쇄하는 사용자 지정 프로세서입니다.
jobConfig.xml
다음은 샘플 Spring Batch 애플리케이션의 구성 파일입니다. 이 파일에서는 작업과 단계를 정의합니다. 이 외에도 ItemReader, ItemProcessor 및 ItemWriter에 대한 빈도 정의합니다. (여기서는 이들을 각각의 클래스와 연결하고 구성하는 데 필요한 속성의 값을 전달합니다.)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = " http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "report" class = "Report" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "dbItemReader"
writer = "mysqlItemWriter" processor = "itemProcessor" commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "dbItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" scope = "step">
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from tutorials_data" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "mysqlItemWriter"
class = "org.springframework.batch.item.xml.StaxEventItemWriter">
<property name = "resource" value = "file:xml/outputs/tutorials.xml" />
<property name = "marshaller" ref = "reportMarshaller" />
<property name = "rootTagName" value = "Tutorial" />
</bean>
<bean id = "reportMarshaller" class = "org.springframework.oxm.jaxb.Jaxb2Marshaller">
<property name = "classesToBeBound">
<list>
<value>Tutorial</value>
</list>
</property>
</bean>
</beans>Context.xml
다음은 context.xmlSpring Batch 애플리케이션의. 이 파일에서는 작업 저장소, 작업 실행기 및 트랜잭션 관리자와 같은 빈을 정의합니다.
<beans xmlns = " http://www.springframework.org/schema/beans"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionMana ger" />
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- connect to MySQL database -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>CustomItemProcessor.java
다음은 프로세서 클래스입니다. 이 클래스에서는 애플리케이션에서 처리 코드를 작성합니다. 여기에서는 각 레코드의 내용을 인쇄합니다.
import org.springframework.batch.item.ItemProcessor;
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}TutorialRowMapper.java
다음은 TutorialRowMapper 데이터를 설정하는 클래스 Tutorial 수업.
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}Tutorial.java
다음은 Tutorial수업. 다음과 같은 간단한 Java 클래스입니다.setter 과 getter행동 양식. 이 클래스에서는 주석을 사용하여이 클래스의 메서드를 XML 파일의 태그와 연결합니다.
import javax.xml.bind.annotation.XmlAttribute;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "details")
public class Tutorial {
int tutorial_id;
String tutorial_author;
String submission_date;
@XmlAttribute(name = "tutorial_id")
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
@XmlElement(name = "tutorial_author")
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
@XmlElement(name = "tutorial_title")
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
@XmlElement(name = "submission_date")
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
public String toString() {
return " [Tutorial Id=" + tutorial_id + ",
Tutorial Author =" + tutorial_author + ",
Tutorial Title =" + tutorial_title + ",
Submission Date =" + submission_date + "]";
}
}App.java
다음은 일괄 처리를 시작하는 코드입니다. 이 수업에서는 JobLauncher를 실행하여 배치 애플리케이션을 시작합니다.
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}이 응용 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.
May 08, 2017 11:32:06 AM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@3d646c37:
startup date [Mon May 08 11:32:06 IST 2017]; root of context hierarchy
May 08, 2017 11:32:06 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [jobs/job_hello_world.xml]
May 08, 2017 11:32:07 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 08, 2017 11:32:14 AM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing... [Tutorial Id=101, Tutorial Author=Sanjay,
Tutorial Title=Learn Java, Submission Date=06-05-2007]
Processing... [Tutorial Id=102, Tutorial Author=Abdul S,
Tutorial Title=Learn MySQL, Submission Date=19-04-2007]
Processing... [Tutorial Id=103, Tutorial Author=Krishna Kasyap,
Tutorial Title=Learn JavaFX, Submission Date=06-07-2017]
May 08, 2017 11:32:14 AM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Exit Status : COMPLETED그러면 다음 내용이 포함 된 XML 파일이 생성됩니다.
<?xml version = "1.0" encoding = "UTF-8"?>
<Tutorial>
<details tutorial_id = "101">
<submission_date>06-05-2007</submission_date>
<tutorial_author>Sanjay</tutorial_author>
<tutorial_title>Learn Java</tutorial_title>
</details>
<details tutorial_id = "102">
<submission_date>19-04-2007</submission_date>
<tutorial_author>Abdul S</tutorial_author>
<tutorial_title>Learn MySQL</tutorial_title>
</details>
<details tutorial_id = "103">
<submission_date>06-07-2017</submission_date>
<tutorial_author>Krishna Kasyap</tutorial_author>
<tutorial_title>Learn JavaFX</tutorial_title>
</details>
</Tutorial>이 장에서 우리는 MySQL Reader를 사용하는 Spring Batch 애플리케이션을 만들고 Flatfile 작성자 (.txt).
Reader − 응용 프로그램에서 사용하는 리더는 JdbcCursorItemReader MySQL 데이터베이스에서 데이터를 읽습니다.
아래와 같이 MySQL 데이터베이스에 테이블을 생성했다고 가정합니다.
CREATE TABLE details.xml_mysql(
person_id int(10) NOT NULL,
sales VARCHAR(20),
qty int(3),
staffName VARCHAR(20),
date VARCHAR(20)
);다음 레코드를 삽입했다고 가정합니다.
mysql> select * from tutorialsdata;
+-------------+-----------------+----------------+-----------------+
| tutorial_id | tutorial_author | tutorial_title | submission_date |
+-------------+-----------------+----------------+-----------------+
| 101 | Sanjay | Learn Java | 06-05-2007 |
| 102 | Abdul S | Learn MySQL | 19-04-2007 |
| 103 | Krishna Kasyap | Learn JavaFX | 06-07-2017 |
+-------------+-----------------+----------------+-----------------+
3 rows in set (0.00 sec)Writer − 애플리케이션에서 사용하는 Writer는 FlatFileItemWriter 데이터를 쓰다 flatfile (.txt).
Processor − 응용 프로그램에서 사용하는 프로세서는 CSV 파일에서 읽은 레코드 만 인쇄하는 사용자 지정 프로세서입니다.
jobConfig.xml
다음은 샘플 Spring Batch 애플리케이션의 구성 파일입니다. 이 파일에서는 작업과 단계를 정의합니다. 이 외에도 ItemReader, ItemProcessor 및 ItemWriter에 대한 빈도 정의합니다. (여기서 우리는 그것들을 각각의 클래스와 연관시키고 그것들을 구성하기 위해 필요한 속성의 값을 전달합니다.)
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:batch = "http://www.springframework.org/schema/batch"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:util = "http://www.springframework.org/schema/util"
xsi:schemaLocation = "http://www.springframework.org/schema/batch
http://www.springframework.org/schema/batch/spring-batch-2.2.xsd
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">
<import resource = "../jobs/context.xml" />
<bean id = "tutorial" class = "Tutorial" scope = "prototype" />
<bean id = "itemProcessor" class = "CustomItemProcessor" />
<batch:job id = "helloWorldJob">
<batch:step id = "step1">
<batch:tasklet>
<batch:chunk reader = "mysqlItemReader"
writer = "flatFileItemWriter" processor = "itemProcessor"
commit-interval = "10">
</batch:chunk>
</batch:tasklet>
</batch:step>
</batch:job>
<bean id = "mysqlItemReader"
class = "org.springframework.batch.item.database.JdbcCursorItemReader" >
<property name = "dataSource" ref = "dataSource" />
<property name = "sql" value = "select * from details.tutorialsdata" />
<property name = "rowMapper">
<bean class = "TutorialRowMapper" />
</property>
</bean>
<bean id = "flatFileItemWriter"
class = " org.springframework.batch.item.file.FlatFileItemWriter">
<property name = "resource" value = "file:target/outputfiles/employee_output.txt"/>
<property name = "lineAggregator">
<bean class = " org.springframework.batch.item.file.transform.PassThroughLineAggregator"/>
</property>
</bean>
</beans>Context.xml
다음은 context.xmlSpring Batch 애플리케이션의. 이 파일에서는 작업 저장소, 작업 실행기 및 트랜잭션 관리자와 같은 빈을 정의합니다.
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xmlns:jdbc = "http://www.springframework.org/schema/jdbc"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
http://www.springframework.org/schema/jdbc
http://www.springframework.org/schema/jdbc/spring-jdbc-3.2.xsd ">
<!-- stored job-meta in database -->
<bean id = "jobRepository"
class = "org.springframework.batch.core.repository.support.JobRepositoryFactoryBean">
<property name = "dataSource" ref = "dataSource" />
<property name = "transactionManager" ref = "transactionManager" />
<property name = "databaseType" value = "mysql" />
</bean>
<bean id = "transactionManager"
class = "org.springframework.batch.support.transaction.ResourcelessTransactionManager" />
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver" />
<property name = "url" value = "jdbc:mysql://localhost:3306/details" />
<property name = "username" value = "myuser" />
<property name = "password" value = "password" />
</bean>
<bean id = "jobLauncher"
class = "org.springframework.batch.core.launch.support.SimpleJobLauncher">
<property name = "jobRepository" ref = "jobRepository" />
</bean>
<!-- create job-meta tables automatically -->
<jdbc:initialize-database data-source = "dataSource">
<jdbc:script location = "org/springframework/batch/core/schema-drop-mysql.sql" />
<jdbc:script location = "org/springframework/batch/core/schema-mysql.sql" />
</jdbc:initialize-database>
</beans>CustomItemProcessor.java
다음은 프로세서 클래스입니다. 이 클래스에서는 애플리케이션에서 처리 코드를 작성합니다. 여기에서는 각 레코드의 내용을 인쇄합니다.
import org.springframework.batch.item.ItemProcessor;
// Implementing the ItemProcessor interface
public class CustomItemProcessor implements ItemProcessor<Tutorial, Tutorial> {
@Override
public Tutorial process(Tutorial item) throws Exception {
System.out.println("Processing..." + item);
return item;
}
}TutorialRowMapper.java
다음은 TutorialRowMapper 데이터를 설정하는 클래스 Tutorial 수업.
public class TutorialRowMapper implements RowMapper<Tutorial> {
@Override
public Tutorial mapRow(ResultSet rs, int rowNum) throws SQLException {
Tutorial tutorial = new Tutorial();
tutorial.setTutorial_id(rs.getInt("tutorial_id"));
tutorial.setTutorial_title(rs.getString("tutorial_title"));
tutorial.setTutorial_author(rs.getString("tutorial_author"));
tutorial.setSubmission_date(rs.getString("submission_date"));
return tutorial;
}
}Tutorial.java
다음은 Tutorial수업. 다음과 같은 간단한 Java 클래스입니다.setter 과 getter행동 양식. 이 클래스에서는 주석을 사용하여이 클래스의 메서드를 XML 파일의 태그와 연결합니다.
public class Tutorial {
private int tutorial_id;
private String tutorial_title;
private String tutorial_author;
private String submission_date;
public int getTutorial_id() {
return tutorial_id;
}
public void setTutorial_id(int tutorial_id) {
this.tutorial_id = tutorial_id;
}
public String getTutorial_title() {
return tutorial_title;
}
public void setTutorial_title(String tutorial_title) {
this.tutorial_title = tutorial_title;
}
public String getTutorial_author() {
return tutorial_author;
}
public void setTutorial_author(String tutorial_author) {
this.tutorial_author = tutorial_author;
}
public String getSubmission_date() {
return submission_date;
}
public void setSubmission_date(String submission_date) {
this.submission_date = submission_date;
}
@Override
public String toString() {
return " [id=" + tutorial_id + ", title=" +
tutorial_title + ",
author=" + tutorial_author + ", date=" +
submission_date + "]";
}
}App.java
다음은 일괄 처리를 시작하는 코드입니다. 이 수업에서는 JobLauncher를 실행하여 배치 애플리케이션을 시작합니다.
import org.springframework.batch.core.Job;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.JobParameters;
import org.springframework.batch.core.launch.JobLauncher;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class App {
public static void main(String[] args) throws Exception {
String[] springConfig = { "jobs/job_hello_world.xml" };
// Creating the application context object
ApplicationContext context = new ClassPathXmlApplicationContext(springConfig);
// Creating the job launcher
JobLauncher jobLauncher = (JobLauncher) context.getBean("jobLauncher");
// Creating the job
Job job = (Job) context.getBean("helloWorldJob");
// Executing the JOB
JobExecution execution = jobLauncher.run(job, new JobParameters());
System.out.println("Exit Status : " + execution.getStatus());
}
}이 응용 프로그램을 실행하면 다음과 같은 출력이 생성됩니다.
May 09, 2017 5:44:48 PM org.springframework.context.support.ClassPathXmlApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXml
ApplicationContext@3d646c37: startup date [Tue May
09 17:44:48 IST 2017]; root of context hierarchy
May 09, 2017 5:44:48 PM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
May 09, 2017 5:44:56 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] launched
with the following parameters: [{}]
May 09, 2017 5:44:56 PM org.springframework.batch.core.job.SimpleStepHandler handleStep
INFO: Executing step: [step1]
Processing...Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Processing...Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Processing...Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=0607-2017]
May 09, 2017 5:44:57 PM org.springframework.batch.core.launch.support.SimpleJobLauncher run
INFO: Job: [FlowJob: [name=helloWorldJob]] completed with the following parameters:
[{}] and the following status: [COMPLETED]
Hello
Exit Status : COMPLETED이것은 .txt 다음 내용을 가진 파일.
Report [id=101, title=Learn Java, author=Sanjay, date=06-05-2007]
Report [id=102, title=Learn MySQL, author=Abdul S, date=19-04-2007]
Report [id=103, title=Learn JavaFX, author=Krishna Kasyap, date=06-07-2017]