Spring EntityManager不合并_Spring_Hibernate_Jpa_Junit

Spring EntityManager不合并

spring hibernate jpa junit

Spring EntityManager不合并,spring,hibernate,jpa,junit,Spring,Hibernate,Jpa,Junit,测试junit添加了一个新角色而不是更新（它不更新）。我使用spring、hibernate、maven、Mysql。有人有主意吗？谢谢： TestJunit.java： ......... public class TestJunit { @Test public void UpdateRole() { InterfAdminMetier metier = (InterfAdminMetier) context .getBean("metier");

测试junit添加了一个新角色而不是更新（它不更新）。我使用spring、hibernate、maven、Mysql。有人有主意吗？谢谢：

TestJunit.java：

.........
public class TestJunit {

@Test
public void UpdateRole() {
    InterfAdminMetier metier = (InterfAdminMetier) context
            .getBean("metier");
    Role r = metier.getRole("ROLE_Test");
    System.out.println("1 before update************************************"+r.getRoleName());
    r.setRoleName("ROLE_TestUpdate");
    metier.updateRole(r);
    System.out.println("2 after update************************************"+metier.getRole("ROLE_Test").getRoleName());
    assertTrue(metier.getRole("ROLE_TestUpdate").getRoleName().contentEquals("ROLE_TestUpdate"));

}
}

User.java：

    ........
//import org.hibernate.mapping.Set;


/*classe JavaBean:les propriétes ne sont accessible que par les gettters et les setters
il faut definir un constructeur sans parametres si non il ne sera pas defini par defaut si nous deffinision un 
constructeur avec parametres*/
@Entity
@Table(name = "users")
public class User implements Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    @Id
    @Column(name = "id")
    private String id;

    private String nom;
    private String prenom;
    private String mail;
    private String pw;

    /*
     * un utilisateur peut avoir plusieurs role comme l'admin qui a les roles
     * admin, biblio, enseignant, etud un role peut etre attribuer a plusieurs
     * utili comme roleEtudiant
     */


/*  @ManyToMany(fetch = FetchType.LAZY, cascade = CascadeType.ALL)
    @JoinTable(name = "roles_users",  joinColumns = {
            @JoinColumn(name = "idUser", nullable = false, updatable = true) },
            inverseJoinColumns = { @JoinColumn(name = "roleName",
                    nullable = false, updatable = true) })
    private Set<Role> roles = new HashSet<Role>(0);*/


    @ManyToMany(fetch = FetchType.LAZY, cascade=CascadeType.ALL)
    @JoinTable(name = "roles_users", joinColumns = { @JoinColumn(name = "idUser", referencedColumnName = "id", nullable = false, updatable = true) }, inverseJoinColumns = { @JoinColumn(name = "roleName", referencedColumnName = "roleName", nullable = false, updatable = true) })
    private Set<Role> roles = new HashSet<Role>(0);
       ........................................
    public User() {
        super();
        // TODO Auto-generated constructor stub
    }

    ..........................................

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getNom() {
        return nom;
    }

    public void setNom(String nom) {
        this.nom = nom;
    }

    public String getPrenom() {
        return prenom;
    }

    public void setPrenom(String prenom) {
        this.prenom = prenom;
    }

    public String getMail() {
        return mail;
    }

    public void setMail(String mail) {
        this.mail = mail;
    }

    public String getPw() {
        return pw;
    }

    public void setPw(String pw) {
        this.pw = pw;
    }

    public Collection<Role> getRoles() {
        return roles;
    }

    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

    ...................................

}

。。。。。。。。
//导入org.hibernate.mapping.Set；
classe JavaBean：我们可以找到一个容易接近的人。
不确定的结构参数
建筑工程师avec参数*/
@实体
@表（name=“users”）
公共类用户实现可序列化{
/**
* 
*/
私有静态最终长serialVersionUID=1L；
@身份证
@列（name=“id”）
私有字符串id；
私有字符串名称；
私有字符串prenom；
私人字符串邮件；
私有字符串pw；
/*
*联合国利用我们的职位和行政管理职能
*管理员、图书馆管理员、信息发布员等
*公用事业公司
*/
/*@ManyToMany（fetch=FetchType.LAZY，cascade=CascadeType.ALL）
@JoinTable（name=“roles\u users”，joinColumns={
@JoinColumn（name=“idUser”，nullable=false，updateable=true）}，
inverseJoinColumns={@JoinColumn（name=“roleName”，
nullable=false，updateable=true）}）
私有集角色=新哈希集（0）*/
@ManyToMany（fetch=FetchType.LAZY，cascade=CascadeType.ALL）
@JoinTable（name=“roles\u users”，joinColumns={@JoinColumn（name=“idUser”，referencedColumnName=“id”，nullable=false，updateable=true）}，inverseJoinColumns={@JoinColumn（name=“roleName”，referencedColumnName=“roleName”，nullable=false，updateable=true）}）
私有集角色=新哈希集（0）；
........................................
公共用户（）{
超级（）；
//TODO自动生成的构造函数存根
}
..........................................
公共字符串getId（）{
返回id；
}
公共无效集合id（字符串id）{
this.id=id；
}
公共字符串getNom（）{
返回名称；
}
公共无效集合名（字符串名）{
this.nom=nom；
}
公共字符串getPrenom（）{
返回prenom；
}
公共void setPrenom（字符串prenom）{
this.prenom=prenom；
}
公共字符串getMail（）{
回信；
}
公共无效设置邮件（字符串邮件）{
this.mail=邮件；
}
公共字符串getPw（）{
返回pw；
}
公共无效设置pw（字符串pw）{
this.pw=pw；
}
公共集合getRoles（）{
返回角色；
}
公共无效集合角色（集合角色）{
this.roles=角色；
}
...................................
}

Role.java：

        ............
    @Entity
    @Table(name = "roles")
    public class Role implements Serializable {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        @Id
        @Column(name = "roleName")
        private String roleName;

        @ManyToMany(fetch = FetchType.LAZY, mappedBy = "roles")
        private Set<User> users = new HashSet<User>(0);

        /*
         * @ManyToMany(fetch = FetchType.LAZY, mappedBy = "roles") private
         * Collection<User> users;
         */

        public Role() {
            super();
            // TODO Auto-generated constructor stub
        }

        public Role(String roleName) {
            super();
            this.roleName = roleName;
        }

        public Collection<User> getUsers() {
            return users;
        }

        public void setUsers(Set<User> users) {
            this.users = users;
        }

        public String getRoleName() {
            return roleName;
        }

        public void setRoleName(String roleName) {
            this.roleName = roleName;
        }

    }

。。。。。。。。。。。。
@实体
@表（name=“roles”）
公共类角色实现可序列化{
/**
* 
*/
私有静态最终长serialVersionUID=1L；
@身份证
@列（name=“roleName”）
私有字符串roleName；
@ManyToMany（fetch=FetchType.LAZY，mappedBy=“roles”）
私有集用户=新哈希集（0）；
/*
*@ManyToMany（fetch=FetchType.LAZY，mappedBy=“roles”）私有
*收集用户；
*/
公共角色（）{
超级（）；
//TODO自动生成的构造函数存根
}
公共角色（字符串角色名）{
超级（）；
this.roleName=roleName；
}
公共集合getUsers（）{
返回用户；
}
公共void集合用户（集合用户）{
this.users=用户；
}
公共字符串getRoleName（）{
返回roleName；
}
public void setRoleName（字符串roleName）{
this.roleName=roleName；
}
}

BiblioDaoImplementation.java：

    ...........
public class BiblioDaoImplementation implements InterfaBiblioDao {
    @PersistenceContext(unitName = "UP_Biblio")
    private EntityManager em;


//  ---------------------------------------user---------------------------------    
    @Override
    public String addUser(User user) {

        em.persist(user);

        return user.getId();
    }

    @Override
    public String removeUser(String id) {

        User user = getUser(id);
        em.remove(user);

        return user.getId();
    }

    @Override
    public String updateUser(User user) {

        em.merge(user);

        return user.getId();
    }

    @Override
    public User getUser(String Id) {

        return em.find(User.class, Id);
    }

    @Override
    public void attrubierRoleToUser(Role role, String id) {

        User u = em.find(User.class, id);

        u.getRoles().add(role);

    }

    @Override
    public List<User> listUsers() {

        Query req = em
                .createQuery("select user from User user");

        return req.getResultList();
    }

    @Override
    public List<User> listUserByRole(String roleName) {

        Query req = em
                .createQuery(" SELECT u FROM Role r JOIN r.users u  WHERE r.roleName=:x");

        req.setParameter("x", roleName);

        return req.getResultList();
    }

//  ---------------------------------------role---------------------------------
    @Override
    public String addRole(Role role) {

        em.persist(role);

        return role.getRoleName();
    }

    @Override
    public String removeRole(String roleName) {
        Role role = em.find(Role.class, roleName);
        em.remove(role);

        return roleName;
    }

    @Override
    public String updateRole(Role role) {

        em.merge(r);



        return role.getRoleName();
    }


    @Override
    public Role getRole(String roleName) {

        return em.find(Role.class, roleName);
    }

    @Override
    public List<Role> listRoles() {

        Query req = em.createQuery("select role from Role role");

        return req.getResultList();
    }
    }

。。。。。。。。。。。
公共类bibliodao的实现实现了interbabliodao{
@PersistenceContext（unitName=“UP\u Biblio”）
私人实体管理者；
//-------------------------------------用户-------------------------------------------
@凌驾
公共字符串addUser（用户）{
em.persist（用户）；
返回user.getId（）；
}
@凌驾
公共字符串移除用户（字符串id）{
User=getUser（id）；
em.remove（用户）；
返回user.getId（）；
}
@凌驾
公共字符串更新器（用户）{
em.merge（用户）；
返回user.getId（）；
}
@凌驾
公共用户getUser（字符串Id）{
返回em.find（User.class，Id）；
}
@凌驾
public void attrubierRoleToUser（角色，字符串id）{
用户u=em.find（User.class，id）；
u、 getRoles（）.add（角色）；
}
@凌驾
公共列表listUsers（）{
查询请求=em
.createQuery（“从用户中选择用户”）；
return req.getResultList（）；
}
@凌驾
公共列表listUserByRole（字符串roleName）{
查询请求=em
.createQuery（“从角色r中选择u加入r.users u，其中r.roleName=：x”）；
要求设置参数（“x”，roleName）；
return req.getResultList（）；
}
//------------------------------------角色---------------------------------
@凌驾
公共字符串addRole（角色）{
em.persist（角色）；
返回role.getRoleName（）；
}
@凌驾
公共字符串移除器OLE（字符串角色名）{
Role-Role=em.find（Role.class，roleName）；
em.remove（角色）；
返回roleName；
}
@凌驾
公共字符串更新程序（角色）{
em.merge（r）；
返回role.getRoleName（）；
}
@凌驾
公共角色getRole（字符串roleName）{
返回em.find（Role.class，roleName）；
}
@凌驾
公共列表listRoles（）{
Query req=em.createQuery（“从角色中选择角色”）；
return req.getResultList（）；
}
}

persistence.xml：

        <?xml version="1.0" encoding="UTF-8"?>
    <persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd ">
      <persistence-unit name="UP_Biblio" transaction-type="RESOURCE_LOCAL">
           <provider>org.hibernate.ejb.HibernatePersistence</provider>
        <properties>
          <property name="hibernate.show_sql" value="true"/>
          <property name="hibernate.hbm2ddl.auto" value="update"/>
          <property name="hibernate.dialect" value="org.hibernate.dialect.MySQLDialect"/>
        </properties>
      </persistence-unit>
    </persistence>


        <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xmlns:s="http://www.springframework.org/schema/security"
        xsi:schemaLocation="http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.2.xsd
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">

      <bean id="datasource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
      <property name="url" value="jdbc:mysql://localhost:3306/biblioissteg"></property>
      <property name="username" value="root"></property>
      <property name="password" value=""></property>
      </bean>


      <bean id="persistenceUnitManager" class="org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager">
      <property name="defaultDataSource" ref="datasource"></property>
     <property name="persistenceXmlLocations">
        <list>
        <value>classpath*:META-INF/persistence.xml</value>
        </list>
    </property>
    </bean>


    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
      <property name="persistenceUnitManager" ref="persistenceUnitManager"></property>
      <property name="persistenceUnitName" value="UP_Biblio"></property>
    </bean>


        <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
            <property name="entityManagerFactory" ref="entityManagerFactory"></property>
        </bean>

        <tx:annotation-driven transaction-manager="transactionManager"/>
        <context:annotation-config></context:annotation-config>

       <bean id="dao" class="tn.issteg.biblio.dao.BiblioDaoImplementation"></bean>
       <bean id="metier" class="tn.issteg.biblio.metier.BiblioMetierImpl">
          <property name="dao" ref="dao"></property>
       </bean>

    </beans>

   public String updateRole(Role role) {

         em.update(role);
    return role.getRoleName();
     }