如何解决循环引用的问题

本文已收录于专栏
《Java》

概念说明

  循环引用是指在对象之间存在相互引用的情况。具体来说,当一个对象A引用了另一个对象B,而对象B又引用了对象A,它们之间形成了一个循环引用关系。
  循环引用可能会导致一些问题,特别是在序列化和反序列化过程中。在序列化过程中,如果不进行特殊处理,循环引用会导致无限递归的序列化,最终导致栈溢出异常。在反序列化过程中,循环引用可能会导致对象的重复创建,破坏对象的一致性。

发现问题

  当我们实现了类之间的多对多关系的时候,当我们从数据库中查询相关数据的时候,会发现查询出来的结果会存在对象之间嵌套的问题,最后导致堆栈溢出的问题。
Classes类

@Service
@Entity
@Table(name="Classes")
public class Classes implements ApplicationRunner {

    private Long id;

    private Long classId;

    private String className;

    private Integer isDelete;


    @OneToMany(mappedBy = "classes")

    private List<ClassesActor> actorClasses;

	//getter和setter方法
	
	}

Actor类

@Service
@Entity
@Table(name = "Actor")
public class Actor  {
    private Long id;

    private String code;

    private String name;

    private String phone;

	@OneToMany(mappedBy = "actor")
    private List<ClassesActor> actorClasses;
	
	//getter和setter方法
	}

ClassesActor类

@Entity
public class ClassesActor {

    private Long id;

    @ManyToOne
    @JoinColumn(name = "actor_id")
    private Actor actor;

    @ManyToOne
    @JoinColumn(name = "class_id")
    private Classes classes;

	//getter和setter方法
	}

  当我在实际的业务中去查询classes相关信息的时候会发现,Classes对象中有ClassesActor对象,点开ClassesActor对象中海油Classes对象而且这些对象都是同一个对象。所以就出现了循环嵌套的问题。
在这里插入图片描述

解决问题

分析问题

   1. 我们要清楚对于对象的属性进行操作属于数据序列化的过程。数据序列化是将对象转换为字节流或其他形式的数据,以便在网络传输、存储或跨平台传递时使用。在数据序列化过程中,对象的属性值会被转换为字节流或其他格式的数据,并随后可以被反序列化为对象。
  2.通过对问题的分析我们可以通过序列化操作来解决序列化多个相同对象的问题,这样我们就把问题缩小到序列化中。
  3.明确如何在序列化的过程中去控制相同的对象只序列化一次,我们的问题也就迎刃而解了。

具体解决

  通过@JsonManagedReference和@JsonBackReference注解帮助我们解决相同的对象只序列化一次的问题。

注解说明

  • 「@JsonManagedReference 」注解用于标注在实体类的属性上,表示该属性是一个“被管理的引用”。它的作用是告诉Jackson在序列化过程中,该属性是“正向”引用,需要被序列化输出。同时,它还需要配合@JsonBackReference注解一起使用,指定“反向”引用的属性。
  • 「@JsonBackReference 」 注解用于标注在实体类的属性上,表示该属性是一个“反向引用”。它的作用是告诉Jackson在序列化过程中,该属性是“反向”引用,不需要被序列化输出。相反,它会通过@JsonManagedReference注解指定的属性来进行序列化输出。

代码实现

Classes类

@Service
@Entity
@Table(name="Classes")
public class Classes implements ApplicationRunner {

    private Long id;

    private Long classId;

    private String className;

    private Integer isDelete;


    @OneToMany(mappedBy = "classes")
	@JsonManagedReference(value = "class-actorClasses")
    private List<ClassesActor> actorClasses;

	//getter和setter方法
	
	}

Actor类

@Service
@Entity
@Table(name = "Actor")
public class Actor  {
    private Long id;

    private String code;

    private String name;

    private String phone;

	@OneToMany(mappedBy = "actor")
	@JsonManagedReference(value = "actor-classes")
    private List<ClassesActor> actorClasses;
	
	//getter和setter方法
	}

ClassesActor类

@Entity
public class ClassesActor {

    private Long id;

    @ManyToOne
    @JoinColumn(name = "actor_id")
    @JsonBackReference(value = "actor-classes")
    private Actor actor;

    @ManyToOne
    @JoinColumn(name = "class_id")
    @JsonBackReference(value = "class-actorClasses")
    private Classes classes;

	//getter和setter方法
	}

  通过使用@JsonManagedReference和@JsonBackReference注解,Jackson库能够正确处理实体类之间的循环引用关系,避免了无限递归的序列化问题。当一个类中出现了多个@JsonBackReference注解要有value值进行区分和加以对应。

效果展示

在这里插入图片描述

总结提升

  这两个注解只适用于序列化过程,对于反序列化过程是不起作用的。如果需要在反序列化时处理循环引用问题,可以考虑使用@JsonIdentityInfo注解或自定义序列化和反序列化逻辑来处理。



在这里插入图片描述


🎯 此文章对你有用的话记得留言+点赞+收藏哦🎯
<think>我们正在讨论Python的weakref模块如何通过弱引用解决循环引用问题。根据提供的引用资料,特别是引用[2]中的示例,我们可以清晰地看到循环引用问题以及弱引用如何解决它。循环引用问题:当两个对象互相引用时(例如,Node对象拥有一个Data对象,而Data对象又引用了其所属的Node对象),它们的引用计数永远不会变为零,因此即使删除外部引用,它们也不会被立即回收。这会导致内存泄漏。弱引用的作用:弱引用允许我们访问对象,但不增加其引用计数。因此,当对象只剩下弱引用时,垃圾回收器可以回收该对象。在引用[2]的示例中:-最初,Node类中的data属性是一个Data实例,而Data实例的owner属性直接指向Node实例(强引用)。这形成了循环引用:node->data->node(强引用),因此引用计数至少为1。-修改后,Data实例的owner属性改为对Node实例的弱引用(使用weakref.ref)。这样,当外部对Node实例的引用被删除时,Node实例的引用计数变为0,可以被回收。同时,Data实例也因为没有其他引用而被回收。使用weakref模块的主要方式:1.使用weakref.ref创建弱引用对象。需要调用该引用对象来获取原对象(如果原对象还存在)。2.使用weakref.proxy创建代理对象,可以直接像原对象一样使用(但要注意原对象可能已被回收)。3.使用WeakKeyDictionary和WeakValueDictionary来创建弱引用的字典。下面我们详细说明原理和具体使用方法。原理:弱引用不会增加对象的引用计数。当一个对象只被弱引用引用时,它会被垃圾回收器视为可回收的对象。垃圾回收器在回收该对象后,会将这些弱引用放入一个队列(可以通过weakref.getweakrefcount和weakref.getweakrefs查看),或者调用之前注册的回调函数(如果创建弱引用时提供了回调)。使用方法(以解决循环引用为例):在可能存在循环引用的地方,将其中一个引用改为弱引用。例如,在父子节点互相引用时,通常将子节点对父节点的引用设为弱引用引用[2]中的代码示例修改:原循环引用代码(有内存泄漏):classNode(object):def__init__(self,value):self.data=Data(value,self)#Data实例的owner是Node实例(强引用)classData(object):def__init__(self,value,owner):self.owner=owner#强引用self.value=value修改后(使用弱引用):importweakrefclassData(object):def__init__(self,value,owner):#使用weakref.ref创建对owner的弱引用self.owner=weakref.ref(owner)self.value=valuedef__str__(self):#使用弱引用时,需要调用它来获取实际对象(如果对象还存在)return"%s'sdata,valueis%s"%(self.owner(),self.value)classNode(object):def__init__(self,value):self.data=Data(value,self)#这里传入self(即当前Node实例)这样,当外部删除对Node实例的引用(如:delnode)时,Node实例的引用计数变为0,随后被回收。同时,Data实例的owner弱引用不再有效(调用返回None),并且Data实例也没有其他引用,因此也被回收。另外,weakref模块还提供了其他工具,如WeakValueDictionary和WeakKeyDictionary,用于创建弱引用的字典。例如,WeakValueDictionary的值是弱引用,当值对象在其他地方被回收时,字典中的条目会自动删除。注意事项:1.弱引用对象需要检查是否还存在,因为调用弱引用可能返回None。2.有些对象不能创建弱引用,比如列表、字典等内置可变类型(除非子类化),以及int、str、tuple等(这些类型不支持弱引用)。但是,类实例、函数等可以创建弱引用。3.弱引用可以带有回调函数,当对象被回收时,回调函数会被调用。总结:使用weakref模块可以避免循环引用导致的内存泄漏问题,通过将循环引用中的一个引用改为弱引用,从而允许垃圾回收器在适当的时候回收对象。下面,根据用户要求,生成相关问题。</think>### Python weakref 模块解决循环引用的原理与使用 #### 一、循环引用问题 当两个对象**互相强引用**时形成循环引用,导致引用计数永不归零: ```python class Node: def __init__(self, value): self.data = Data(value, self) # 强引用Data对象 class Data: def __init__(self, value, owner): self.owner = owner # 强引用Node对象 → 循环引用! ``` 此时执行 `del node` 后,由于 `Node` 和 `Data` 互相持有强引用,垃圾回收器无法立即回收内存。 #### 二、弱引用解决原理 弱引用(weakref)**允许访问对象但不增加其引用计数**。当对象只剩弱引用时,垃圾回收器可正常回收: ```python import weakref class Data: def __init__(self, value, owner): self.owner = weakref.ref(owner) # 关键修改:弱引用Node对象 ``` 此时对象关系变为: ``` Node ──强引用→ Data Data ──弱引用→ Node ``` 删除 `node` 后,`Node` 引用计数归零被回收 → `Data` 失去唯一强引用也被回收。 #### 三、weakref 核心方法 | 方法/类 | 作用 | 示例 | |------------------------|----------------------------------------------------------------------|----------------------------------------------------------------------| | `weakref.ref(obj)` | 创建基本弱引用,需调用返回的对象 | `owner_ref = weakref.ref(node); obj = owner_ref()` | | `weakref.proxy(obj)` | 创建透明代理,直接访问原对象属性 | `owner_proxy = weakref.proxy(node); print(owner_proxy.value)` | | `WeakValueDictionary` | 值弱引用的字典,当值被回收时自动删除条目 | `cache = WeakValueDictionary(); cache["key"] = large_obj` | #### 四、解决循环引用的完整示例 ```python import weakref class Data: def __init__(self, value, owner): self.owner = weakref.ref(owner) # 弱引用Node self.value = value def __str__(self): owner_obj = self.owner() # 解引用获取Node对象 return f"{owner_obj.name}'s data" if owner_obj else "Orphaned data" class Node: def __init__(self, name, value): self.name = name self.data = Data(value, self) # Data持有Node的弱引用 # 测试 node = Node("A", 100) print(node.data) # 输出: A's data del node # 删除强引用 # 此时Node和Data均被回收 ``` #### 五、注意事项 1. **弱引用失效处理**:解引用时需检查返回是否为 `None` ```python if ref() is not None: ref().do_something() ``` 2. **不可弱引用的类型**:基础类型(int, str, tuple等)和部分容器(list, dict)不能直接创建弱引用 3. **回调函数机制**:对象回收时触发回调 ```python def on_gc(): print("Object recycled!") ref = weakref.ref(obj, on_gc) ``` > **关键原理总结** > 弱引用通过不增加目标对象引用计数,打破循环引用的闭环。当外部强引用消失时,垃圾回收器能识别出“孤立环”并回收内存[^2]。 --- ###
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

武梓龙_Wzill

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值