Tengo que escribir una clase diferente para leer un archivo de diferente tipo. Ahora el proyecto se implementa en el lado del cliente. Y tenemos que dar soporte a los nuevos archivos. así que tenemos que crear una nueva clase y también modificar en la clase de servicio para crear un nuevo objeto de clase recién agregada Escribir una nueva clase para un nuevo tipo de clase está bien. Pero no quiero cambiar la clase de servicio cada vez. ¿Hay alguna solución para este tipo de problema? Gracias por adelantado.

Actualización 1: aquí está el código de clase de servicio

 @Service("StockistServiceImpl")
 public class StockistServiceImpl implements StockistService {

@Override
@Transactional(propagation = Propagation.REQUIRED,rollbackFor=Exception.class)
public JSONArray saveStockistOrder(Integer stockistId,
        MultipartFile[] orderFile, String orderNumber, String orderDate,
        String partyCode,String order,Integer userId) 
{
                            List<Pair<String, Integer>> charList = new ArrayList<Pair<String, Integer>>();
                            Properties code1 = new Properties();
                            try {
                                code.load(StockistServiceImpl.class.getClassLoader().getResourceAsStream("categoryOfFile.properties"));
                            }
                            catch (IOException e) {
                                //System.out.println("error in loading divisionNamePdfCode.properties");
                                e.printStackTrace();
                            }
                            String readDuelListedTxtFile = code.getProperty("readDuelListedTxtFile");
                            String readStartLineLengthForOrderTxtFile = code.getProperty("readStartLineLengthForOrderTxtFile");
                            String ReadFileWithNoStartLineTxtFile = code.getProperty("ReadFileWithNoStartLineTxtFile");
                            String ReadStartLineLengthForQtySingleListTxtFile = code.getProperty("ReadStartLineLengthForQtySingleListTxtFile");

                            if (readDuelListedTxtFile.contains(partyCode
                                    .trim())) {
                                charList.addAll(dualListText
                                            .readDuelListedTxtFile(
                                                    fileName, codeDetails));
                            }
                            else if (readStartLineLengthForOrderTxtFile.contains(partyCode
                                    .trim())) {
                                charList.addAll(lineLength
                                            .readStartLineLengthForOrderTxtFile(
                                                    fileName, codeDetails));
                            }
                            else if (ReadFileWithNoStartLineTxtFile.contains(partyCode
                                    .trim())) {
                                T_FileWithNoStartLine noStartLine = new T_FileWithNoStartLine();
                                charList.addAll(noStartLine
                                            .readFileWithNoStartLineTxtFile(
                                                    fileName, codeDetails));
                            }
                            else if (ReadStartLineLengthForQtySingleListTxtFile.contains(partyCode
                                    .trim())) {
                                T_StartLineLengthForQtySingleList noStartLine = new T_StartLineLengthForQtySingleList();
                                charList.addAll(noStartLine
                                            .readStartLineLengthForQtySingleListTxtFile(
                                                    fileName, codeDetails));
                            }
}

Actualización 2: aquí hay un archivo de propiedades desde donde sabemos qué es el tipo de archivo para un almacenista.

#fileType,stockistCode
fileType1=ST001,ST009
fileType2=ST002,ST005,ST006
fileType3=ST003,ST007
fileType4=ST004,ST008

Y quiero agregar un nuevo archivo de propiedad como este para asignar un tipo de archivo con el nombre de la clase, de modo que si se agrega una nueva clase y no tendremos que editar la clase de servicio.

#fileType,fullyqualifiedclassName
fileType1=FullyQualifiedClassName1
fileType2=FullyQualifiedclassName2
fileType3=FullyQualifiedClassName3
fileType4=FullyQualifiedclassName4
0
Gaurav Rajput 25 dic. 2016 a las 11:19

3 respuestas

La mejor respuesta

Separe la creación de los objetos lectores de archivos y la clase de servicio.

public class BuildFileReader() {
    FileReader getReader(String xyz) {
        FileReader reader;

        ...
        your logic
        reader = new WhatEverReaderYouWant();
        ...

        return reader;
    }
}

La clase de servicio simplemente le pregunta a BuildFileReader qué FileReader debe usar y ya no necesita cambiar.

public class StockistServiceImpl {
    ...
    BuildFileReader bfr = new BuildFileReader();

    FileReader fileReader = bfr.getReader(xyz); 

    fileReader.readFile(fileName, codeDetails);
    ...
}

Si solo necesita un tipo de lector de archivos por cliente, puede configurar su BuildFileReader para cada cliente. Si necesita más de un tipo de lector de archivos por cliente, defina una interfaz para cada tipo y agregue una función getReaderXYZ () para cada tipo necesario en BuildFileReader.

1
jaysee 25 dic. 2016 a las 09:58

Finalmente, después de hacer algunos cambios en el código y agregar el archivo de propiedades para asignar nombres de clase con la propiedad del archivo, aquí está el código y funciona bien.

@Service("StockistServiceImpl")
public class StockistServiceImpl implements StockistService {

 List<Pair<String, Integer>> charList = new ArrayList<Pair<String, Integer>>();


 Map<String,String> mapTxtFile = new HashMap<String, String>();
                            Properties fileTypeProperties = new Properties();
                            Properties matchClassNameProperties = new Properties();
                            try {
                                fileTypeProperties.load(StockistServiceImpl.class.getClassLoader().getResourceAsStream("fileTypeProperties.properties"));
                            }
                            catch (IOException e) {

                                //e.printStackTrace();
                            }
                            try {
                                matchClassNameProperties.load(StockistServiceImpl.class.getClassLoader().getResourceAsStream("matchClassNameProperties.properties"));
                            }
                            catch (IOException e) {

                                //e.printStackTrace();
                            }

                            for (String key : fileTypeProperties.stringPropertyNames()) {
                                String value = fileTypeProperties.getProperty(key);
                                mapTxtFile.put(key, value);

                                if(value.contains(partyCode.trim())){                                       
                                    String className = matchClassNameProperties.getProperty(key);
                                    try {
                                        Class clazz =   Class.forName(className);
                                        try {
                                            TxtFile objToReadTxtFile = (TxtFile) clazz.newInstance();
                                            charList= objToReadTxtFile.readTxtFile(fileName, codeDetails);

                                        } catch (InstantiationException e) {
                                            // TODO Auto-generated catch block
                                            e.printStackTrace();
                                        } catch (IllegalAccessException e) {
                                            // TODO Auto-generated catch block
                                            e.printStackTrace();
                                        }

                                    } catch (ClassNotFoundException e) {
                                        // TODO Auto-generated catch block
                                        e.printStackTrace();
                                    }
                                }else{
                                    //read normally else block

                                }
                            }


}

Ahora está funcionando bien, pero para eso creé una interfaz para leer el archivo txt que tiene el método readTxtFile. y todas las demás clases ahora implementan esta interfaz.

0
Gaurav Rajput 2 ene. 2017 a las 07:38

La instancia se puede crear en tiempo de ejecución utilizando reflexión en Java, por favor, eche un vistazo a la siguiente publicación:

Crear una instancia usando el nombre de la clase y llamar al constructor

1
Community 23 may. 2017 a las 12:33