如何摆脱em.persist()；

Question

我不喜欢再写em.persist()了。我可以在返回新实例的同时执行此操作吗？

嗯，也许id和grails-domain混淆了。

在示例中，我得到了一个AppConfig.java：

package spring;
import org.springframework.context.annotation.*;
import org.springframework.orm.jpa.*;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.*;

@Configuration
@EnableAspectJAutoProxy
@EnableTransactionManagement
public class AppConfig implements TransactionManagementConfigurer {

    @Bean
    public LocalEntityManagerFactoryBean entityManagerFactory() {
        LocalEntityManagerFactoryBean bean = new LocalEntityManagerFactoryBean();
        bean.setPersistenceUnitName("persistenceUnit");
        return bean;
    }

    @Bean
    @Scope("session")
    public Test test() {
        return new Test();
    }

    @Bean
    public JpaTransactionManager txManager() {
        return new JpaTransactionManager();
    }

    public PlatformTransactionManager annotationDrivenTransactionManager() {
        return txManager();
    }
}

和实体用户

package spring;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity @Table(name = "User")
public class User {
    private long id;
    @Id
    @GeneratedValue
    public long getId() { return id; }
    public void setId(long id) { this.id = id; }


    private String name;
    @Column
    public void setName(String name) { this.name = name; }
    public String getName() { return name; }

}

一个persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence xmlns="http://java.sun.com/xml/ns/persistence" version="2.0">
    <persistence-unit name="persistenceUnit">
        <properties>
            <property name="hibernate.ejb.cfgfile" value="/META-INF/hibernate.cfg.xml" />
        </properties>
    </persistence-unit>
</persistence>

和一个hibernate.cfg.xml

    <?xml version="1.0" encoding="utf-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
        <session-factory name="sessionFactory">
            <property name="hibernate.hbm2ddl.auto">false</property>
            <property name="hibernate.connection.driver_class">org.hsqldb.jdbcDriver</property>
            <property name="hibernate.connection.password"></property>
            <property name="hibernate.hbm2ddl.auto">create-drop</property>
            <property name="hibernate.connection.url">jdbc:hsqldb:mem:jamsession</property>
            <property name="hibernate.connection.username">sa</property>
            <property name="hibernate.dialect">org.hibernate.dialect.HSQLDialect</property>
            <property name="hibernate.search.autoregister_listeners">false</property>
            <property name="hibernate.show_sql">true</property>
            <property name="hibernate.format_sql">false</property>
            <mapping class="spring.User" />
        </session-factory>
    </hibernate-configuration>

名为Test的控制器：

package spring;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Controller;
import org.springframework.transaction.annotation.Transactional;

@Controller
public class Test {
    @PersistenceContext
    transient EntityManager em;

    @Transactional
    public User newUser(String name) {
        User user = new User();
        user.setName(name);
        // em.persist(user);
        return user;
    }

    public List<User> getUsers() {
        return em.createQuery("from User").getResultList();
    }
}

最后但并非最不重要的是，这个index.jsp：

<%@page import="spring.User"%>
<%@page import="spring.Test"%>
<%@page import="org.springframework.web.context.WebApplicationContext"%>
<%@page import="org.springframework.web.context.support.WebApplicationContextUtils"%>
<%
    WebApplicationContext wac = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
    Object o = wac.getBean("appConfig");
    Test test = (Test) wac.getBean("test");
    if (request.getParameter("insert") != null) {
        test.newUser(request.getParameter("name"));
    }
%>
<ol>
<% for (User u : test.getUsers()) {
     out.print("<li>"+u.getName()+"</li>");
   } %>
</ol>

<form method="post">
  <input type="text" name="name" value="unnamed" />
  <input type="submit" value="Insert" name="insert" />
</form>

要使用插入按钮保存新用户，我需要em.persist(user);！我怎样才能摆脱em.persist？

Answer 1

您可以使用AOP :)来摆脱em.persist。在函数执行之后，您可以对自己进行注释，以便对它返回的任何内容执行em.persist() :)..

您可以：

1. 在java环境下编写一个拦截器...
2. 如果您使用spring
3. 使用一些DAO来操纵对象

<代码>G212

如果你使用的是spring，使用AOP要容易得多。只要谷歌它的AOP和发明任何你想要的.

您也可以使用spring-data ...给你很多东西..。只需编写一个接口，就完成了..。spring-data将实现您的接口...

在这里您可以看到一个spring-data项目

1. spring-data JPA
2. an interface that will be implemented by spring (using AOP)

附言:这不是一个笑话……您不必为该接口编写任何实现...你只需要使用诸如"save()，findUserByName(String name)“之类的命名约定就可以了。

Answer 2

可以这样做的一种方法是使用根对象中的cascade。在您的示例中，可能User属于某个Department。您可以为该类提供一个到User的@OneToMany映射，标记为CascadeType.ALL

@Entity
public class Department {
    @OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
    private Set<User> users;
}

然后，要创建用户，请创建该用户并将其添加到Department

Department d = em.find(Department.class, "Coinage");
User u = new User("Felix Schlag");
d.addUser(u);

当提交封闭的事务时，将保存现有的但已修改的Department，并且保存也将级联到新的User。

如果没有像Department这样的User的自然聚合，您可以为所有用户创建一个主根对象。或者，您可以将用户分为不同的类型(管理员、客户、作者等等)，并为每种用户创建一个UserType实例，其中包含该类型的所有用户。

最后，我应该说，虽然这种方法在技术上是可行的，但我认为它通常不是一个好主意。我会担心遇到与让多个线程并发更新根对象的集合相关的问题(这可能表现为事务提交失败)，或者将这些巨大的集合加载到内存中(这不应该是必需的，但无论如何都可能发生)。

Answer 3

是的你可以。此外，您还可以：

用更少的耦合( code

• accomplish )实现相同的功能用更简单的code

• accomplish实现相同的功能用更容易理解的代码实现相同的功能使用更容易理解的代码实现相同的功能

• 增加耦合(这使得代码的维护成本更低)

这一切都是通过使用GORM而不是CMP来实现的。请注意，这只是一个观点。

在这一点上没有行业共识，也没有更普遍的Spring持久性与CMP的争论。因此，您的组织应该对此进行彻底的讨论。

理想情况下，利弊应该以客观的方式记录下来，并通过现实世界的证据进行权衡。只有这样，您的组织才能做出明智的决策，并且您应该坚持这一点。

不幸的是，有一些人持有“封闭的信仰”(也就是强烈的观点)，他们偏爱其中之一。更好的架构师正在等待基于证据的结果。

从本质上讲，意见是基于收集、解释和基于时间的信息(这意味着随着时间的推移，意见会随着时间的推移而变化，因为收集的信息越多，理解就越好。)It (IMHO)中的一个常见问题是，决策更少地基于证据，而更多地基于最具影响力的人的意见。

我观察到许多人混淆了观点和事实。

一些IT领导者(例如Venkat Subramaniam )警告不要过度使用注释，因为它们将您的代码耦合到特定的实现。您的代码使用了大量注释。

Spring框架的好处之一是，大多数类都没有引用Spring，并且是完全解耦的。业界普遍认为，解耦可以降低维护成本。

Spring将配置从代码移动到外部(XML)配置文件。这被广泛认为是应用程序架构发展的积极一步。

Grails和Ruby on Rails框架采取了下一步，通过“约定重于配置”消除了大多数配置文件。

查看代码片段的一种方法是将它们还原到两代以前的解决方案，即紧密耦合的解决方案(具有讽刺意味的是，为了利用“新”技术)。

再说一次，这只是一种观点。但我发现，在实践中，很少有组织客观地权衡利弊。