Scénario

pour simplifier, supposons que j'ai un lecteur D'Item qui me renvoie 25 lignes.

1. Les 10 premières lignes appartiennent à l'étudiant Un

2. les 5 suivants appartiennent à l'élève B

3. et les 10 restants appartiennent à l'élève C

je veux les rassembler, logiquement dire par studentId et les aplatir pour finir avec une rangée par étudiant.

Problème

Si je comprends bien, le réglage de l'intervalle de validation à 5 procédez de la manière suivante:

1. envoyer 5 lignes au processeur (qui les regroupera ou fera n'importe quelle logique commerciale à laquelle je le dirai).
2. après le traitement écrira 5 lignes.
3. puis il le refera pour les 5 prochaines rangées et ainsi de suite.

Si cela est vrai, alors pour les cinq prochaines je vais vérifier le déjà écrit les uns, les faire sortir les agréger à ceux que je suis en train de traiter et les écrire à nouveau.

personnellement, je ne fais pas ça.

1. Quelle est la meilleure pratique pour gérer une situation comme celle-ci dans le Lot de printemps?

Autres

parfois j'ai l'impression qu'il est beaucoup plus facile d'écrire un programme principal JDBC printemps régulier et puis j'ai le contrôle total de ce que je veux faire. Cependant, je voulais profiter du référentiel d'emplois surveillance de l'état de la tâche, la capacité de redémarrer, skip, travail et écouteurs étape....

Mon Code De Lot De Printemps

Mon module-contexte.xml

   <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:batch="http://www.springframework.org/schema/batch"
    xsi:schemaLocation="http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch-2.1.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

    <description>Example job to get you started. It provides a skeleton for a typical batch application.</description>

    <batch:job id="job1">
        <batch:step id="step1"  >           
            <batch:tasklet transaction-manager="transactionManager" start-limit="100" >             
                 <batch:chunk reader="attendanceItemReader"
                              processor="attendanceProcessor" 
                              writer="attendanceItemWriter" 
                              commit-interval="10" 
                 />

            </batch:tasklet>
        </batch:step>
    </batch:job> 

    <bean id="attendanceItemReader" class="org.springframework.batch.item.database.JdbcCursorItemReader"> 
        <property name="dataSource">
            <ref bean="sourceDataSource"/>
        </property> 
        <property name="sql"                                                    
                  value="select s.student_name ,s.student_id ,fas.attendance_days ,fas.attendance_value from K12INTEL_DW.ftbl_attendance_stumonabssum fas inner join k12intel_dw.dtbl_students s on fas.student_key = s.student_key inner join K12INTEL_DW.dtbl_schools ds on fas.school_key = ds.school_key inner join k12intel_dw.dtbl_school_dates dsd on fas.school_dates_key = dsd.school_dates_key where dsd.rolling_local_school_yr_number = 0 and ds.school_code = ? and s.student_activity_indicator = 'Active' and fas.LOCAL_GRADING_PERIOD = 'G1' and s.student_current_grade_level = 'Gr 9' order by s.student_id"/>
        <property name="preparedStatementSetter" ref="attendanceStatementSetter"/>           
        <property name="rowMapper" ref="attendanceRowMapper"/> 
    </bean> 

    <bean id="attendanceStatementSetter" class="edu.kdc.visioncards.preparedstatements.AttendanceStatementSetter"/>

    <bean id="attendanceRowMapper" class="edu.kdc.visioncards.rowmapper.AttendanceRowMapper"/>

    <bean id="attendanceProcessor" class="edu.kdc.visioncards.AttendanceProcessor" />  

    <bean id="attendanceItemWriter" class="org.springframework.batch.item.file.FlatFileItemWriter"> 
        <property name="resource" value="file:target/outputs/passthrough.txt"/> 
        <property name="lineAggregator"> 
            <bean class="org.springframework.batch.item.file.transform.PassThroughLineAggregator" /> 
        </property> 
    </bean> 

</beans>

mes cours de soutien pour le lecteur.

A PreparedStatementSetter

package edu.kdc.visioncards.preparedstatements;

import java.sql.PreparedStatement;
import java.sql.SQLException;

import org.springframework.jdbc.core.PreparedStatementSetter;

public class AttendanceStatementSetter implements PreparedStatementSetter {

    public void setValues(PreparedStatement ps) throws SQLException {

        ps.setInt(1, 7);

    }

}

et un RowMapper

package edu.kdc.visioncards.rowmapper;

import java.sql.ResultSet;
import java.sql.SQLException;

import org.springframework.jdbc.core.RowMapper;

import edu.kdc.visioncards.dto.AttendanceDTO;

public class AttendanceRowMapper<T> implements RowMapper<AttendanceDTO> {

    public static final String STUDENT_NAME = "STUDENT_NAME";
    public static final String STUDENT_ID = "STUDENT_ID";
    public static final String ATTENDANCE_DAYS = "ATTENDANCE_DAYS";
    public static final String ATTENDANCE_VALUE = "ATTENDANCE_VALUE";

    public AttendanceDTO mapRow(ResultSet rs, int rowNum) throws SQLException {

        AttendanceDTO dto = new AttendanceDTO();
        dto.setStudentId(rs.getString(STUDENT_ID));
        dto.setStudentName(rs.getString(STUDENT_NAME));
        dto.setAttDays(rs.getInt(ATTENDANCE_DAYS));
        dto.setAttValue(rs.getInt(ATTENDANCE_VALUE));

        return dto;
    }
}

Mon processeur

package edu.kdc.visioncards;

import java.util.HashMap;
import java.util.Map;

import org.springframework.batch.item.ItemProcessor;

import edu.kdc.visioncards.dto.AttendanceDTO;

public class AttendanceProcessor implements ItemProcessor<AttendanceDTO, Map<Integer, AttendanceDTO>> {

    private Map<Integer, AttendanceDTO> map = new HashMap<Integer, AttendanceDTO>();

    public Map<Integer, AttendanceDTO> process(AttendanceDTO dto) throws Exception {

        if(map.containsKey(new Integer(dto.getStudentId()))){

            AttendanceDTO attDto = (AttendanceDTO)map.get(new Integer(dto.getStudentId()));
            attDto.setAttDays(attDto.getAttDays() + dto.getAttDays());
            attDto.setAttValue(attDto.getAttValue() + dto.getAttValue());

        }else{
            map.put(new Integer(dto.getStudentId()), dto);
        }
        return map;
    }

}

Mes préoccupations de code ci-dessus

dans le processeur, je crée un HashMap rangées je vérifie si J'ai déjà cet élève dans la carte, si ce N'est pas là je l'ajoute. Si elle est déjà là, je prends l'il obtenir les valeurs qui m'intéressent et les ajouter avec la ligne que je suis en cours de traitement.

après cela, Spring Batch Framework écrit dans un fichier selon ma configuration

Ma question est comme suit:

1. je ne veux pas aller à l'écrivain. Je veux traiter toutes les lignes restantes. Comment puis-je garder cette Carte J'ai créé en mémoire pour la prochaine série de lignes qui doivent passer par ce même Processeur? À chaque fois, une ligne est traitée via AttendanceProcessor la carte est initialisée. Dois-je mettre l'initialisation de la carte dans un bloc statique?