Java JMapper-映射双向关系的正确方法

使用jMapper映射双向关系的正确方法是什么

我试图使用@jmaconversion注释，但无法阻止无限循环

这是我的密码：

public class SourceClass1 {
    private SourceClass2 sourceClass2;

    //others attributes, getters and setters


}

public class SourceClass2 {
    private SourceClass1 sourceClass1;

    //others attributes, getters and setters

}

public class DestinationClass1 {
    private DestinationClass2 destinationClass2;

    //others attributes, getters and setters

    @JMapConversion(from="sourceClass2", to="destinationClass2", type=Type.DYNAMIC)
    public static String destinationClass2Conversion(){
        StringBuffer stBuffer = new StringBuffer();
        stBuffer.append("if (${destination} != null && ${destination}.getName() != null && !${destination}.getName().isEmpty()) {")
        .append("return ${destination};")
        .append('}')
        .append("return JMapConverter.toDestinationClass2(${destination}, ${source});");

        return stBuffer.toString();

    }
}

public class DestinationClass2 {
    private DestinationClass1 destinationClass1;

    //others attributes, getters and setters

    @JMapConversion(from="sourceClass1", to="destinationClass1", type=Type.DYNAMIC)
    public static String destinationClass1Conversion(){
        StringBuffer stBuffer = new StringBuffer();
        stBuffer.append("if (${destination} != null && ${destination}.getId() != null && !${destination}.getId().isEmpty()) {")
        .append("return ${destination};")
        .append('}')
        .append("return JMapConverter.toDestinationClass1(${destination}, ${source});");

        return stBuffer.toString();

    }
}
public class JMapConverter{

    public static DestinationClass1 toDestinationClass1(DestinationClass1 destinationClass1, SourceClass1 sourceClass1){

        JMapper<DestinationClass1, SourceClass1> mapper = 
                new JMapper<DestinationClass1, SourceClass1>(DestinationClass1.class, SourceClass1.class, ChooseConfig.DESTINATION);

        if (destinationClass1 == null){
            destinationClass1 = mapper.getDestination(sourceClass1); //always passing here
        } else {
            mapper.getDestination(destinationClass1, sourceClass1);
        }
        return destinationClass1;
    }

    public static DestinationClass2 toDestinationClass2(DestinationClass2 destinationClass2, SourceClass2 sourceClass2){

        JMapper<DestinationClass2, SourceClass2> mapper = 
                new JMapper<DestinationClass2, SourceClass2>(DestinationClass2.class, SourceClass2.class, ChooseConfig.DESTINATION);

        if (destinationClass2 == null){
            destinationClass2 = mapper.getDestination(sourceClass2);
        } else {
            mapper.getDestination(destinationClass2, sourceClass2);
        }
        return destinationClass2;
    }
}

公共类SourceClass1{
私有SourceClass2 SourceClass2；
//其他属性、getter和setter
}
公共类SourceClass2{
私人来源类别1来源类别1；
//其他属性、getter和setter
}
公共类DestinationClass1{
私人目的类别2目的类别2；
//其他属性、getter和setter
@JMapConversion（from=“sourceClass2”，to=“destinationClass2”，type=type.DYNAMIC）
公共静态字符串destinationClass2Conversion（）{
StringBuffer stBuffer=新的StringBuffer（）；
追加（“如果（${destination}！=null&&${destination}.getName（）！=null&&！${destination}.getName（）.isEmpty（））{”）
.append（“return${destination}；”）
.append（“}”）
.append（“返回jmaconverter.toDestinationClass2（${destination}，${source}）；”；
返回stBuffer.toString（）；
}
}
公共类目标类2{
私人目的类别1目的类别1；
//其他属性、getter和setter
@JMapConversion（from=“sourceClass1”，to=“destinationClass1”，type=type.DYNAMIC）
公共静态字符串destinationClass1Conversion（）{
StringBuffer stBuffer=新的StringBuffer（）；
追加（“如果（${destination}！=null&&${destination}.getId（）！=null&&！${destination}.getId（）.isEmpty（））{”）
.append（“return${destination}；”）
.append（“}”）
.append（“返回jmaconverter.toDestinationClass1（${destination}，${source}）；”；
返回stBuffer.toString（）；
}
}
公共类JMapConverter{
公共静态DestinationClass1到DestinationClass1（DestinationClass1 DestinationClass1，SourceClass1 SourceClass1）{
JMapper映射器=
新JMapper（DestinationClass1.class，SourceClass1.class，ChooseConfig.DESTINATION）；
if（destinationClass1==null）{
destinationClass1=mapper.getDestination（sourceClass1）；//始终在此处传递
}否则{
getDestination（destinationClass1，sourceClass1）；
}
返回目的类别1；
}
公共静态DestinationClass2到DestinationClass2（DestinationClass2 DestinationClass2，SourceClass2 SourceClass2）{
JMapper映射器=
新JMapper（DestinationClass2.class，SourceClass2.class，ChooseConfig.DESTINATION）；
if（destinationClass2==null）{
destinationClass2=mapper.getDestination（sourceClass2）；
}否则{
getDestination（destinationClass2，sourceClass2）；
}
返回目的类别2；
}
}

结果是：java.lang.StackOverflowerError对源属性使用显式转换：

@JMapConversion(from={"sourceClass2"}, to={"fieldNameInDestinationClass"})
public FieldInDestClassType conversion(SourceClass2 sourceClass2){
    // do the conversion;
}

否则，在试图计算源对象中有多少属性时，框架将崩溃。

对源属性使用显式转换：

@JMapConversion(from={"sourceClass2"}, to={"fieldNameInDestinationClass"})
public FieldInDestClassType conversion(SourceClass2 sourceClass2){
    // do the conversion;
}

---

否则，当试图计算源对象中有多少属性时，框架将崩溃。

使用JMapper无法控制递归，必须显式实现一个块<代码>动态转换在需要以相同模式处理不同字段时非常有用，在您的情况下，

静态

转换就足够了。

使用JMapper无法控制递归，您必须显式实现一个块<代码>动态转换在需要以相同模式处理不同字段时非常有用，在您的情况下，

静态

转换就足够了