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);
        }
    }
}

它使用Transferable进行数据传输，我称之为AcquisitionTransferable（最后可以看到）。

我的问题来自这部分

资料来源：KineticsTransferHandler.canImport(TransferHandler.TransferSupport)

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

我最终在source（上面的那个）中的结构就像真实的结构一样。当我调试时，我可以看到source的ID与真实ID不同。

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

所以，我在想的是，getTransferData中的结构访问存在问题，这可能是序列化的一个问题。当我访问我的结构时，getTransferData反序列化结构，这就是为什么我得到它的克隆。

你知道我应该怎么解决它吗？

Answer 1

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

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

另外检查另外两个Java对象MIME类型here。

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

1 个答案: