在数据传输中反序列化后不是同一个对象

Question

我真的需要一些帮助..。

我正在处理Jtree中的拖放事件。

我已经创建了一个TransferHandler来管理拖放。

来源：KineticsTransferHandler.java

package tree;

import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;

import javax.swing.JComponent;
import javax.swing.JTree;
import javax.swing.TransferHandler;
import javax.swing.tree.TreePath;

import datastructures.base.Acquisition;
import datastructures.base.Kinetics;
import datastructures.base.Location;

public class KineticsTransferHandler extends TransferHandler{
    private static final long serialVersionUID = -5653477841078614666L;

    final public static DataFlavor ACQUISITION_NODE = new DataFlavor(Acquisition.class, "Acquisition Node");

    static DataFlavor flavors[] = { ACQUISITION_NODE };

    @Override
    public int getSourceActions(JComponent c) {
        return MOVE;
    }

    @Override
    protected Transferable createTransferable(JComponent c) {
        JTree tree = (JTree) c;
        TreePath path = tree.getSelectionPath();

        System.out.println(tree.getSelectionPath().toString());

        if (path != null) {
            Object o = path.getLastPathComponent();
            if(o instanceof Acquisition) {
                return new AcquisitionTransferable((Acquisition)o);
            }
        }
        return null;
    }

    @Override
    protected void exportDone(JComponent source, Transferable data, int action) {
        if(action != NONE) {
            JTree tree = (JTree) source;
            StudyTreeModel model = (StudyTreeModel)tree.getModel();
            model.printStudy();

            tree.updateUI();
        }
    }

    @Override
    public boolean canImport(TransferHandler.TransferSupport support) {
        boolean canImport = false;
        if (support.isDrop()) {
            Acquisition source = null;

            if (support.isDataFlavorSupported(ACQUISITION_NODE)) {
                try {
                    source = (Acquisition) support.getTransferable().getTransferData(ACQUISITION_NODE);
                } catch (UnsupportedFlavorException e) {
                    e.printStackTrace();
                } catch (IOException e) {
                    e.printStackTrace();
                }

                if(source != null) {
                    JTree.DropLocation dropLocation = (JTree.DropLocation)support.getDropLocation();
                    Object dest = dropLocation.getPath().getLastPathComponent();            
                    canImport = sameLocation(source, dest);
                }
            }
        }
        return canImport;
    }

    /*Verifies that the source and the dest are in the same Location*/
    private boolean sameLocation(Acquisition source, Object dest) {
        /*...
        A method to check if the source has the same Location than the dest.
        ...*/
    }

    @Override
    public boolean importData(TransferHandler.TransferSupport support) {
        boolean importData = false;
        if (canImport(support)) {
            Acquisition source = null;

            if (support.isDataFlavorSupported(ACQUISITION_NODE)) {
                try {
                    source = (Acquisition) support.getTransferable().getTransferData(ACQUISITION_NODE);
                    ((StudyTree)support.getComponent()).gettr
                } catch (UnsupportedFlavorException e) {
                    e.printStackTrace();
                    return false;
                } catch (IOException e) {
                    e.printStackTrace();
                    return false;
                }

                JTree.DropLocation dropLocation = (JTree.DropLocation)support.getDropLocation();
                Object dest = dropLocation.getPath().getLastPathComponent();

                int childIndex = dropLocation.getChildIndex();
                if (sameLocation(source, dest)) {// dest and source get the same Location
                /*...
                Management of the drop according to the dest.
                ...*/
            }
        }
        return importData;
    }

    public class AcquisitionTransferable implements Transferable {
        Acquisition acquisition;

        public AcquisitionTransferable(Acquisition s) {
            acquisition = s;
        }

        @Override
        public Object getTransferData(DataFlavor flavor)
                throws UnsupportedFlavorException {
            if (!isDataFlavorSupported(flavor))
                throw new UnsupportedFlavorException(flavor);
            return acquisition;
        }

        @Override
        public DataFlavor[] getTransferDataFlavors() {
            return flavors;
        }

        @Override
        public boolean isDataFlavorSupported(DataFlavor flavor) {
            return ACQUISITION_NODE.equals(flavor);
        }
    }
}  

它使用一个我称为AcquisitionTransferable的Transferable进行数据传输(正如您在最后看到的那样)。

我的问题来自这一部分

来源：KineticsTransferHandler.canImport(TransferHandler.TransferSupport)

source = (Acquisition) support.getTransferable().getTransferData(ACQUISITION_NODE);

最后，我在source(上面的那个)中的结构就像是真实结构的副本。当我调试时，我可以看到source的ID与真实的不同。

但是在support(KineticsTransferHandler.canImport(TransferHandler.TransferSupport)的参数)中，我有一个包含结构的Jtree，这是最好的一个。

所以，我想的是，在访问getTransferData中的结构时出现了问题，这可能是序列化的问题。当我访问我的结构时，getTransferData对结构进行反序列化，这就是为什么我像是它的克隆。

你知道我该怎么修吗？

Answer 1

您需要使用javaJVMLocalObjectMimeType定义您的DataFlavor，以表示传输的数据驻留在本地JVM中。在您的示例中，DataFlavor定义应如下所示：

final public static DataFlavor ACQUISITION_NODE = 
    new DataFlavor(DataFlavor.javaJVMLocalObjectMimeType+"; class=\"" +Acquisition.class.getCanonicalName()+"\"" 
    ,"Acquisition Node");

还要检查其他两种Java object MIME类型here。