映射MariaDB几何体指向自定义的Hibernate类型 [英] Map MariaDB geometry Point to custom Hibernate type

问题描述

我想使用Hibernate将MariaDB Point 字段映射到自定义的 Vector2 类型.

I want to map a MariaDB Point field to a custom Vector2 type with Hibernate.

我有下表:

CREATE TABLE `ships` (
    `accounts_id` int   NOT NULL,
    `maps_id`     int   NOT NULL,
    `position`    point NOT NULL
) ENGINE InnoDB CHARACTER SET utf8;

我想将它映射到这样的类:

And I want to map it to a class like this:

class Ship {
    public Account account;
    public Map map;
    public Vector2 position;
}

问题来自 position 字段，如何将其映射到已经存在的类型?

The problem comes with the position field, how do I map it to an already existing type?

我发现的解决方案暗示要使用 hibernate-spatial 来使用其 Point 类，但是我想使用我的 Vector2 类而不是那个

The solutions I've found implied using hibernate-spatial in order to use its Point class, however I want to use my Vector2 class instead of that one

推荐答案

经过数小时的阅读，我终于明白了.

After some hours of reading I figured it out.

首先，我需要一种简单的方法来获取 point 列的X和Y坐标.根据手册，它们存储在WKB中，但是，当我尝试检索原始字节时，出现了一些错误:

First I need a simple way to get the X and Y coordinates of a point column. According to the manual they are stored in WKB, HOWEVER, when I tried myself to retrieve the raw bytes something wasn't right:

ResultSet rs = statement.executeQuery("SELECT * FROM accounts_ships");
rs.next();

byte[] position = rs.getBytes("position");
// position ==> byte[25] { 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 80, -44, 64, 0, 0, 0, 0, 0, 0, -55, 64 }

数组的开头增加了4个字节.在某种程度上，一切都是正确的，因此我在牢记这些字节的同时继续解析结果:

There were 4 additional bytes to the beginning of the array. A part of this, everything was right so I proceeded to parse the result while keeping in mind those bytes:

var in = new ByteArrayInputStream(rs.getBytes(names[0]));
if (in.available() == 25) {
    in.skip(4);
}

var order = ByteOrder.BIG_ENDIAN;
if (in.read() == 1) {
    order = ByteOrder.LITTLE_ENDIAN;
}

var typeBytes = new byte[4];
var xBytes    = new byte[8];
var yBytes    = new byte[8];

try {
    in.read(typeBytes);
    in.read(xBytes);
    in.read(yBytes);
} catch (Exception e) {
    throw new HibernateException("Can't parse point column!", e);
}

var type = ByteBuffer.wrap(typeBytes)
                     .order(order);

if (type.getInt() != 1) {
    throw new HibernateException("Not a point!");
}

var x = ByteBuffer.wrap(xBytes)
                  .order(order);
var y = ByteBuffer.wrap(yBytes)
                  .order(order);

return new Vector2((float) x.getDouble(), (float) y.getDouble());

剩下的唯一要做的事情就是创建一个自定义类型，以便休眠状态可以解析它.

And the only thing left to do was to make a custom type so hibernate had something to parse it.

TL; DR这是工作代码:

TL;DR here's the working code:

package com.manulaiko.kalaazu.persistence.database;

import com.manulaiko.kalaazu.math.Vector2;

import org.hibernate.HibernateException;
import org.hibernate.annotations.TypeDef;
import org.hibernate.annotations.TypeDefs;
import org.hibernate.engine.spi.SharedSessionContractImplementor;
import org.hibernate.usertype.UserType;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.Serializable;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Types;

/**
 * Vector2 type.
 * =============
 *
 * Maps a MySQL geometry point to a Vector2 object.
 *
 * @author Manulaiko <[e-mail]>
 */
@TypeDefs({
        @TypeDef(name = "point", typeClass = com.manulaiko.kalaazu.math.Vector2.class)
})
public class Vector2Type implements UserType {
    @Override
    public int[] sqlTypes() {
        return new int[]{
                Types.BINARY
        };
    }

    @Override
    public Class returnedClass() {
        return Vector2.class;
    }

    @Override
    public boolean equals(Object o, Object o1) throws HibernateException {
        return o.equals(o1);
    }

    @Override
    public int hashCode(Object o) throws HibernateException {
        return o.hashCode();
    }

    @Override
    public Object nullSafeGet(
            ResultSet rs, String[] names,
            SharedSessionContractImplementor sharedSessionContractImplementor, Object o
    ) throws HibernateException, SQLException {
        var in = new ByteArrayInputStream(rs.getBytes(names[0]));
        if (in.available() == 25) {
            // The WKB format says it's 21 bytes,
            // however, when testing, it retrieved 25 bytes
            // so skip first 4 bytes which are 0.
            in.skip(4);
        }

        var order = ByteOrder.BIG_ENDIAN;
        if (in.read() == 1) {
            order = ByteOrder.LITTLE_ENDIAN;
        }

        var typeBytes = new byte[4];
        var xBytes    = new byte[8];
        var yBytes    = new byte[8];

        try {
            in.read(typeBytes);
            in.read(xBytes);
            in.read(yBytes);
        } catch (Exception e) {
            throw new HibernateException("Can't parse point column!", e);
        }

        var type = ByteBuffer.wrap(typeBytes)
                             .order(order);

        if (type.getInt() != 1) {
            throw new HibernateException("Not a point!");
        }

        var x = ByteBuffer.wrap(xBytes)
                          .order(order);
        var y = ByteBuffer.wrap(yBytes)
                          .order(order);

        return new Vector2((float) x.getDouble(), (float) y.getDouble());
    }

    @Override
    public void nullSafeSet(
            PreparedStatement stmt, Object value, int index,
            SharedSessionContractImplementor sharedSessionContractImplementor
    ) throws HibernateException, SQLException {
        if (value == null) {
            stmt.setNull(index, Types.BINARY);
            return;
        }

        if (!(value instanceof Vector2)) {
            throw new UnsupportedOperationException("can't convert " + value.getClass());
        }

        var v = (Vector2) value;
        try {
            // Store it as 25 bytes because it's how my db server stored it.
            var out = new ByteArrayOutputStream(25);
            out.write(new byte[4]);

            // Store byte order the same as the system's
            if (ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN) {
                out.write(0);
            } else {
                out.write(1);
            }

            out.write(
                    ByteBuffer.allocate(8)
                              .putDouble((double) v.x)
                              .array()
            );
            out.write(
                    ByteBuffer.allocate(8)
                              .putDouble((double) v.y)
                              .array()
            );

            stmt.setBytes(index, out.toByteArray());
        } catch (Exception e) {
            throw new HibernateException("Couldn't write point!", e);
        }
    }

    @Override
    public Object deepCopy(Object value) throws HibernateException {
        if (value == null) {
            return null;
        }

        if (!(value instanceof Vector2)) {
            throw new UnsupportedOperationException("can't convert " + value.getClass());
        }
        return new Vector2((Vector2) value);
    }

    @Override
    public boolean isMutable() {
        return true;
    }

    @Override
    public Serializable disassemble(Object value) throws HibernateException {
        if (!(value instanceof Vector2)) {
            throw new UnsupportedOperationException("can't convert " + value.getClass());
        }

        return new Vector2((Vector2) value);
    }

    @Override
    public Object assemble(Serializable serializable, Object o) throws HibernateException {
        return serializable;
    }

    @Override
    public Object replace(Object o, Object o1, Object o2) throws HibernateException {
        return o;
    }
}

这篇关于映射MariaDB几何体指向自定义的Hibernate类型的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！