java - ¿Cómo puedo evitar que Eclipse suministre clases en desuso al importar?

java-7 eclipse-kepler

Question

Tengo un problema recurrente al utilizar Eclipse . Considere el siguiente ejemplo:

Como puedes ver, he presionado Ctrl + Shift + O. Puedo elegir entre una anotación desaprobada y una no desaprobada . Mi problema es que a menudo me suministran docenas de clases y la mitad de ellas están en desuso (un ejemplo perfecto son las clases JUnit Assert ).

Mi pregunta es ¿cómo puedo hacer que Eclipse ignore todas las clases en desuso al organizar las importaciones?

Answer 1

Actualmente Eclipse no ofrece tal opción ... Documentación de Eclipse para Organizar Importaciones (versión Kepler) .

Sin embargo, con un fudge puedes lograr el mismo resultado ...

Eclipse le permite proporcionar una lista de clases / paquetes para filtrar. Para ello, vaya a Preferencias> Filtros de tipo.

He hecho esto en mi entorno para garantizar que no se sugiera "java.awt.List" cuando realmente quiero "java.util.List".

Lo que desea es agregar todas las clases en desuso a esta lista.

Esta lista se mantiene en sus preferencias de espacio de trabajo de eclipse ...

File ... C:/Users/[YOUR_USER_NAME]/workspace/.metadata/.plugins/org.eclipse.core.runtime/.settings/org.eclipse.jdt.ui.prefs
Property ... org.eclipse.jdt.ui.typefilter.enabled=java.awt.List;

Todo lo que se requiere es que cree una lista de clases en desuso y la almacene en este archivo de propiedades.

Eclispe puede ayudar a crear esta lista ... Realizar una "Búsqueda en Java" para "En desuso".

Luego agrupa los resultados por tipo.

Y copie los resultados usando "Copiar nombre calificado"

Los resultados contendrán Genéricos, y esto debería ser eliminado. Por ejemplo, "javafx.scene.control.Cell <T>" debería leer "javafx.scene.control.Cell".

Además de contener clases en desuso, los resultados también contendrán cualquier clase que tenga la palabra "En desuso". Esto podría ser un comentario o una anotación del método. Esta lista deberá filtrarse para conservar solo las clases en desuso.

La siguiente secuencia de comandos procesa esta lista de clases para eliminar los genéricos y filtrar las clases que no están en desuso (es decir, solo tiene la depreciación de métodos). La lista de clases se lee desde un archivo llamado "DeprecatedClassList.txt". Cuando no puede verificar la anotación de clase, se salta la clase y la imprime (para verificación manual).

import java.lang.annotation.Annotation;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class ConfigurationGenerator {

    public static void main(String[] args) throws Exception {

        List<String> cleanedList = Files
                .readAllLines(Paths.get("DeprecatedClassList.txt")).stream()
                .map(ConfigurationGenerator::removeGenerics)
                .filter(ConfigurationGenerator::hasDeprecatedConstructor)
                .collect(Collectors.toList());

        String propertyName = "org.eclipse.jdt.ui.typefilter.enabled=";
        String propertyValue = String.join(";", cleanedList).concat(";");

        String configuration = propertyName + propertyValue;
        System.out.println("Configuration property...");
        System.out.println(configuration);
    }

    public static String removeGenerics(String className) {
        int openingBracket = className.indexOf("<");
        if (openingBracket == -1)
            return className;
        else
            return className.substring(0, openingBracket);
    }

    public static boolean hasDeprecatedConstructor(String className) {

        Class theClass = null;
        try {
            theClass = Class.forName(className);
        } catch (Throwable e) {
            // Ignore bad results
            System.out.println("Skipping: " + className);
            return false;
        }

        Annotation[] annotations = theClass.getAnnotations();
        Optional<Annotation> deprecatedConstructor = Stream
                .of(annotations)
                .filter(annotation -> annotation.toString().equals(
                        "@java.lang.Deprecated()")).findAny();

        return deprecatedConstructor.isPresent();
    }
}

Sin embargo, hay un problema con este enfoque. Es posible que desee utilizar una clase en desuso cuando no existe una versión en desuso. No verá la clase en desuso si se ha ocultado a propósito. Para resolverlo, solo asegúrese de excluirlos del filtro.