Umbenennen von Paketen in Eclipse

Question

In Eclipse "Package Explorer", sagen wir, ich eine Liste von Paketen wie dieses:

• com.dog
• com.cat
• com.frog

Wenn ich den "com" -Teil der Paketstruktur in "animal" umbenennen möchte, dann könnte ich jedes Paket (oben) auswählen und einen Refactor ausführen> umbenennen.

Wenn ich viele Pakete habe, die mit "com" beginnen, kann dieser Prozess eine Weile dauern. Gibt es eine einfache Möglichkeit, den Namen des "com" -Pakets umzubenennen, ohne jedes Paket einzeln im Paket-Explorer umbenennen zu müssen? oder diese Pakete vor dem Umbenennen aus dem Build-Pfad entfernen?

Ich habe versucht, in den Bereich "Navigator", wo es die Ordner in einer Baumstruktur anzeigt, aber ich habe nicht die Umbenennungsfunktion gegeben.

Answer 1

standardmäßig leer geordneten Pakete sind im Paket-Explorer versteckt, wenn Sie die Filter ... im Paket-Explorer ändern Leere Eltern Pakete deaktivieren (dritte von oben in der zweiten Screenshot) Sie werden in der Lage sein, um die leeren Pakete zu sehen.

filters view http://archive.eclipse.org/eclipse/downloads/drops/R-2.1-200303272130/images/non-shared-project-filter.gif

können Sie dann die com Paket umbenennen und überprüfen die Subpackages Option Benennen Sie alle untergeordneten Pakete zu zwingen, umbenannt werden.

rename package http://archive.eclipse.org/eclipse/downloads/drops/R-3.2-200606291905/new_noteworthy/images/hierarchical_package_rename.png

Dann, wenn Sie die Filter fertig sind erneut wieder all die leeren Verpackungen zu verstecken.

Answer 2

Es sieht aus wie die aktuelle JDT API (Java Development Tool, das Teil, das Paket renamming enthält) nur ein Paket zu einem Zeitpunkt nicht umbenennen (und nicht die Unterpakete)

See:

• bug 255484

Wenn ein Paket Refactoring, die Subpackages hat, schafft JDT Kind Pakete wieder, anstatt nur die paren Umbenennung t

• bug 255683: IPackageFragment should offer API for hierarchical rename

wir brauchen eine API auf IPackageFragment umbenennen nicht nur das Fragment, sondern auch auch alle Subpackages.
Effektiv würde benennen Sie die Implementierung auf den Ordner des Pakets Fragment und dann die Paket Erklärungen in allen enthaltenen CUs aktualisieren (einschließlich der in Subpackages)

So ist es „by design“ an dann vor (Eclipse 3.5), aber eine Erweiterung wird protokolliert und wird für 3.6 berücksichtigt.

Hinweis: Das "Fehlen von Funktion" wurde seit 2005 bemerkt!

• bug 109988

ich den neuen hierarchische Paket Umbenennungs teste und hatte zwei Quellordner mit gleicher Paketstruktur. Um die Pakete in beiden umzubenennen, musste ich die gleiche Operation zweimal durchführen.
Es wäre schön einen Hinweis zu bekommen und gefragt zu werden, ob die Paketumbenennung auch auf die anderen Quellordner angewendet werden soll.

Answer 3

Erstellen Sie eine Datei in Ihrem 'com' Paket. Benennen Sie es um und markieren Sie 'Unterpakete umbenennen'. Löschen Sie die Datei.

Answer 4

Ich habe versucht, ein Plugin zum Umbenennen von übergeordneten Paketen zu implementieren. Es fügt dem Kontextmenü von oder kann durch ctrl-7 Element "Parent-Paket umbenennen" hinzugefügt werden.

Ich habe den Code nicht implementiert, um den Menüeintrag basierend auf der aktiven Auswahl zu aktivieren/deaktivieren (es gibt eine Race-Bedingung, die dazu führt, dass der Assistent aufhört abzubrechen). Wenn die aktive Auswahl ein Paket mit einem übergeordneten Paket ist, wird dieses übergeordnete Element ausgewählt und der Umbenennungsassistent wird gestartet. Sie müssen "Unterpakete umbenennen" noch manuell auswählen.

Hier ist der Plugin-Code:

package name.seller.rich.packagerenamer.actions; 

import org.eclipse.core.commands.AbstractHandler; 
import org.eclipse.core.commands.ExecutionEvent; 
import org.eclipse.core.commands.ExecutionException; 
import org.eclipse.jdt.core.IJavaElement; 
import org.eclipse.jdt.core.IPackageFragment; 
import org.eclipse.jdt.core.IPackageFragmentRoot; 
import org.eclipse.jdt.core.JavaModelException; 
import org.eclipse.jdt.internal.ui.JavaPlugin; 
import org.eclipse.jdt.internal.ui.actions.SelectionConverter; 
import org.eclipse.jdt.ui.actions.RenameAction; 
import org.eclipse.jface.viewers.IStructuredSelection; 
import org.eclipse.jface.viewers.StructuredSelection; 
import org.eclipse.ui.IWorkbenchPart; 
import org.eclipse.ui.handlers.HandlerUtil; 

public class RenameParentPackageHandler extends AbstractHandler { 

    public RenameParentPackageHandler() { 
    } 

    public Object execute(ExecutionEvent event) throws ExecutionException { 
     IWorkbenchPart activePart = HandlerUtil.getActivePart(event); 
     try { 
      IStructuredSelection selection = SelectionConverter 
        .getStructuredSelection(activePart); 

      IPackageFragment parentPackage = getParentPackage(selection); 

      if (parentPackage != null && parentPackage.exists()) { 

       RenameAction action = new RenameAction(HandlerUtil 
         .getActiveSite(event)); 

       StructuredSelection parentSelection = new StructuredSelection(
         parentPackage); 
       action.run(parentSelection); 
      } 
     } catch (JavaModelException e) { 
      logException(e); 
     } 
     return null; 
    } 

    private IPackageFragment getParentPackage(IStructuredSelection selection) { 
     IJavaElement[] elements = SelectionConverter.getElements(selection); 

     if (elements != null && elements.length > 0) { 
      if (elements[0] != null && elements[0] instanceof IPackageFragment) { 
       IPackageFragment fragment = (IPackageFragment) elements[0]; 

       String packageName = fragment.getElementName(); 
       int lastDotIndex = packageName.lastIndexOf("."); 

       if (lastDotIndex != -1) { 
        String parentPackageName = packageName.substring(0, 
          lastDotIndex); 

        IJavaElement parent = fragment.getParent(); 
        if (parent != null 
          && parent instanceof IPackageFragmentRoot) { 

         return ((IPackageFragmentRoot) parent) 
           .getPackageFragment(parentPackageName); 

        } 
       } 
      } 
     } 
     return null; 
    } 

    protected void logException(Exception e) { 
     JavaPlugin.log(e); 
    } 
} 

Hier ist die plugin.xml

<?xml version="1.0" encoding="UTF-8"?> 
<?eclipse version="3.0"?> 
<plugin> 
    <extension 
    point="org.eclipse.ui.commands"> 
     <command 
     name="Rename parent package" 
     categoryId="name.seller.rich.packagerenamer.category" 
     id="name.seller.rich.packagerenamer.renameParentPackage"> 
     </command> 
    </extension> 
    <extension 
    point="org.eclipse.ui.handlers"> 
     <handler 
     commandId="name.seller.rich.packagerenamer.renameParentPackage" 
     class="name.seller.rich.packagerenamer.actions.RenameParentPackageHandler"> 
     </handler> 
    </extension> 
    <extension 
    point="org.eclipse.ui.bindings"> 
     <key 
     commandId="name.seller.rich.packagerenamer.renameParentPackage" 
     contextId="org.eclipse.ui.contexts.window" 
     sequence="M1+7" 
     schemeId="org.eclipse.ui.defaultAcceleratorConfiguration"> 
     </key> 
    </extension> 
    <extension 
    point="org.eclipse.ui.menus"> 
     <menuContribution 
     locationURI="popup:org.eclipse.ui.popup.any?after=additions"> 
     <command 
      commandId="name.seller.rich.packagerenamer.renameParentPackage" 
      mnemonic="K"> 
     </command> 
     </menuContribution> 
    </extension> 
</plugin> 

Und das Manifest:

Manifest-Version: 1.0 
Bundle-ManifestVersion: 2 
Bundle-Name: Classwizard 
Bundle-SymbolicName: name.seller.rich.packagerenamer; singleton:=true 
Bundle-Version: 1.0.0 
Require-Bundle: org.eclipse.ui, 
org.eclipse.core.runtime, 
org.eclipse.jdt.core;bundle-version="3.5.0", 
org.eclipse.core.expressions;bundle-version="3.4.100", 
org.eclipse.jface.text;bundle-version="3.5.0", 
org.eclipse.jdt.ui;bundle-version="3.5.0", 
org.eclipse.ui.ide;bundle-version="3.5.0", 
org.eclipse.ui.editors;bundle-version="3.5.0", 
org.eclipse.core.resources;bundle-version="3.5.0" 
Eclipse-AutoStart: true 
Bundle-RequiredExecutionEnvironment: JavaSE-1.6 

Answer 5

Ähm, ich weiß nicht, was alle anderen hier tut, aber in Eclipse Juno mit der rechten Maustaste auf den Packacge -> Refactor -> Umbenennen

Benennen Sie dann Ihre Pakete einfach um und aktivieren Sie das Kontrollkästchen, wenn die Änderungen in der Hierarchie kaskadieren sollen.