Question

我不想再写em.persist（）了。我可以在返回新实例时执行此操作吗？

嗯，好吧，也许与grails-domains混淆。

在示例中，我得到了一个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（用户）;！我怎样才能摆脱em.persist？

Answer 1

你可以使用em.persist :)摆脱AOP你可以在执行函数之后对自己做一个注释来执行它返回的任何内容的em.persist() :)

你可以：

在java ee ...
如果您使用spring

aspectj

使用一些DAO来操纵对象

如果你使用弹簧使用AOP要容易得多......只需谷歌搜索AOP并发明任何你想要的东西......

你也可以使用spring-data ...给你很多东西......只需编写一个界面就可以了...... spring-data将实现你的界面...

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

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

PS：这不是一个笑话......你不必为那些接口编写任何实现......你只需要使用命名约定，如“save()，findUserByName(String name)”等......

Answer 2

您可以通过使用根对象中的cascade来实现此目的。在您的情况下，User可能属于Department。您可以将该@OneToMany映射到User，标记为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。

如果User之类的Department没有自然聚合，则可以为所有用户创建单个主根对象。或者，您可以将用户分类为类型（管理员，客户，作者，等等），并为每个类型设置一个UserType实例，并包含该类型的所有用户的集合。

我应该说，虽然这种方法在技术上是可行的，但我认为这通常不是一个好主意。我会担心遇到与多个线程同时更新根对象集合（可能表现为事务提交失败）或将这些巨型集合加载到内存（这可能不是必需的，但仍可能发生）相关的问题）。

Answer 3

是的，你可以。另外你可以：

使用更少的代码完成相同的功能
使用更简单的代码完成相同的功能
使用更易于阅读的代码实现相同的功能
使用更易于理解的代码实现相同的功能
更高效
减少耦合（这使您的代码维护成本更低）

通过使用GORM而不是CMP，您可以获得所有这些。请注意，这只是一个观点。

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

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

不幸的是，人们有着“坚定的信念”（又名强烈的观点），这种观点偏向于另一个。恕我直言，更好的建筑师正在等待基于证据的结果。

意见本质上是基于收集，解释和基于时间的信息（意味着意见随着时间的推移而变化，因为收集更多信息并且理解得到改善。）这是IT（恕我直言）中的常见问题。决策的依据不是证据，而是更多地基于影响最大的人的意见。

我观察到很多人将意见与事实混为一谈。

一些IT领导者（例如Venkat Subramaniam）警告不要过度使用注释，因为他们将您的代码与特定实现相结合。您的代码使用大量注释。

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

Spring将配置从代码移动到外部（XML）配置文件。这被广泛视为应用程序架构发展的积极步骤。

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

查看代码片段的一种方法是将它们恢复两代，转换为紧密耦合的解决方案（具有讽刺意味的是，为了利用“新”技术。）

同样，这只是一个意见。但我发现，在实践中，很少有组织客观地权衡利弊。

Answer 4

如果您想使用hibernate在数据库中存储用户域对象，您只需在某处调用em.persist(user)。将持久性操作包装在数据访问层中被认为是一种很好的做法。数据访问层使用EntityManager执行常见的持久性操作，如save，find，remove，list，count ...），并使用EntityManager封装操作。上面的数据访问层应该是事务服务层，它提供与您的应用程序相关的业务方法，例如UserService方法createUserAccount - 服务层调用数据访问层执行基本操作操作（例如，在事务内部保存用户并为其分配一些安全角色）。最后，应用程序中的控制器应仅与服务层通信 - 这样您就可以从低级ORM API中进行抽象。

如何摆脱em.persist（）;

4 个答案: