在play framework 1.2.x的JPABase分析类中，为什么使用调用saveAndCascade（）？ public void\u save（）{ 如果（！em（）.包含（此））{ em（）.persist（这个）； postEvent（“JPASupport.objectPersisted”，这个）； } avoidCascadeSaveLoops.set（新的ArrayList（））； 试一试{ saveAndCascade（true）； }最后{ avoidCascadeSaveLoops.get（）.clear（）； } 试一试{ em（）.flush（）； }捕获（持久异常e）{ if（例如，getCause（）实例为GenericJDBCException）{ 抛出新的PersistenceException（（（GenericJDBCException）e.getCause（））.getSQL（））； }否则{ 投掷e； } } avoidCascadeSaveLoops.set（新的ArrayList（））； 试一试{ saveAndCascade（false）； }最后{ avoidCascadeSaveLoops.get（）.clear（）； } } 私有void saveAndCascade（布尔值willBeSaved）{ this.willBeSaved=willBeSaved； if（avoidCascadeSaveLoops.get（）.contains（this））{ 返回； }否则{ avoidCascadeSaveLoops.get（）.add（此）； 如果（将被保存）{ postEvent（“JPASupport.objectUpdated”，这个）； } } //级联保存 试一试{ Set fields=new HashSet（）； Class clazz=this.getClass（）； 而（！clazz.equals（JPABase.class））{ Collections.addAll（fields，clazz.getDeclaredFields（））； clazz=clazz.getSuperclass（）； } 用于（字段：字段）{ 字段。setAccessible（true）； if（Modifier.isTransient（field.getModifiers（）））{ 继续； } 布尔doCascade=false； if（字段isAnnotationPresent（OneToOne.class））{ doCascade=cascadeAll（field.getAnnotation（OneToOne.class.cascade（））； } if（字段isAnnotationPresent（OneToMany.class））{ doCascade=cascadeAll（field.getAnnotation（OneToMany.class.cascade（））； } if（字段isAnnotationPresent（ManyToOne.class））{ doCascade=cascadeAll（field.getAnnotation（manytone.class.cascade（））； } if（field.isAnnotationPresent（ManyToMany.class））{ doCascade=cascadeAll（field.getAnnotation（manytomy.class.cascade（））； } 国际单项体育联合会（doCascade）{ 对象值=field.get（此）； 如果（值==null）{ 继续； } if（PersistentMap的值instanceof）{ 如果（（（PersistentMap）值）.wasInitialized（））{ 对于（对象o:（（映射）值）.values（））{ if（o JPABase实例）{ （JPABase）o.保存和级联（willBeSaved）； } } } 继续； } if（PersistentCollection的值instanceof）{ if（（（PersistentCollection）值）.wasInitialized（）{ for（对象o:（集合）值）{ if（o JPABase实例）{ （JPABase）o.保存和级联（willBeSaved）； } } } 继续； } if（HibernateProxy的值实例和JPABase的值实例）{ 如果（！（（HibernateProxy）值）.getHibernateLazyInitializer（）.isUninitialized（））{ （（JPABase）（（HibernateProxy）值）.getHibernateLazyInitializer（）.getImplementation（））.saveAndCascade（willBeSaved）； } 继续； } if（JPABase的值实例）{ （（JPABase）值）.saveAndCascade（willBeSaved）； 继续； } } } }捕获（例外e）{ 抛出新的意外异常（“在级联save（）期间”，e）； } }

为什么使用saveAndCascade（）调用？ 我看了源代码，但不明白。 感谢您的帮助

我想学习如何使用playframework，但我不能理解它。我读了《Play+Framework+Cookbook》和《Wayne Ellis-介绍Play Framework》这两本书，但我找不到关于Play source的一些分析。

---

欢迎阅读任何书籍、文档或语句。

在正常的JPA环境中，EntityManager.flush（）方法将检查所有加载的实体，如果它们被修改，更改将保存回数据库

Play-1的工作方式不同-此函数设置willBeSaved变量，稍后Hibernate拦截器将对其进行检查，并仅允许更新此特定实体，因此，如果存在其他修改的实体，则不会对其进行更新

 public void _save() {
        if (!em().contains(this)) {
            em().persist(this);
            PlayPlugin.postEvent("JPASupport.objectPersisted", this);
        }
        avoidCascadeSaveLoops.set(new ArrayList<JPABase>());
        try {
            saveAndCascade(true);
        } finally {
            avoidCascadeSaveLoops.get().clear();
        }
        try {
            em().flush();
        } catch (PersistenceException e) {
            if (e.getCause() instanceof GenericJDBCException) {
                throw new PersistenceException(((GenericJDBCException) e.getCause()).getSQL());
            } else {
                throw e;
            }
        }
        avoidCascadeSaveLoops.set(new ArrayList<JPABase>());
        try {
            saveAndCascade(false);
        } finally {
            avoidCascadeSaveLoops.get().clear();
        }
    }


private void saveAndCascade(boolean willBeSaved) {
    this.willBeSaved = willBeSaved;
    if (avoidCascadeSaveLoops.get().contains(this)) {
        return;
    } else {
        avoidCascadeSaveLoops.get().add(this);
        if (willBeSaved) {
            PlayPlugin.postEvent("JPASupport.objectUpdated", this);
        }
    }
    // Cascade save
    try {
        Set<Field> fields = new HashSet<Field>();
        Class clazz = this.getClass();
        while (!clazz.equals(JPABase.class)) {
            Collections.addAll(fields, clazz.getDeclaredFields());
            clazz = clazz.getSuperclass();
        }
        for (Field field : fields) {
            field.setAccessible(true);
            if (Modifier.isTransient(field.getModifiers())) {
                continue;
            }
            boolean doCascade = false;
            if (field.isAnnotationPresent(OneToOne.class)) {
                doCascade = cascadeAll(field.getAnnotation(OneToOne.class).cascade());
            }
            if (field.isAnnotationPresent(OneToMany.class)) {
                doCascade = cascadeAll(field.getAnnotation(OneToMany.class).cascade());
            }
            if (field.isAnnotationPresent(ManyToOne.class)) {
                doCascade = cascadeAll(field.getAnnotation(ManyToOne.class).cascade());
            }
            if (field.isAnnotationPresent(ManyToMany.class)) {
                doCascade = cascadeAll(field.getAnnotation(ManyToMany.class).cascade());
            }
            if (doCascade) {
                Object value = field.get(this);
                if (value == null) {
                    continue;
                }
                if (value instanceof PersistentMap) {
                    if (((PersistentMap) value).wasInitialized()) {
                        for (Object o : ((Map) value).values()) {
                            if (o instanceof JPABase) {
                                ((JPABase) o).saveAndCascade(willBeSaved);
                            }
                        }
                    }
                    continue;
                }
                if (value instanceof PersistentCollection) {
                    if (((PersistentCollection) value).wasInitialized()) {
                        for (Object o : (Collection) value) {
                            if (o instanceof JPABase) {
                                ((JPABase) o).saveAndCascade(willBeSaved);
                            }
                        }
                    }
                    continue;
                }
                if (value instanceof HibernateProxy && value instanceof JPABase) {
                    if (!((HibernateProxy) value).getHibernateLazyInitializer().isUninitialized()) {
                        ((JPABase) ((HibernateProxy) value).getHibernateLazyInitializer().getImplementation()).saveAndCascade(willBeSaved);
                    }
                    continue;
                }
                if (value instanceof JPABase) {
                    ((JPABase) value).saveAndCascade(willBeSaved);
                    continue;
                }
            }
        }
    } catch (Exception e) {
        throw new UnexpectedException("During cascading save()", e);
    }
}