BlogJava-雪山飞鹄-随笔分类-Hibernate

基于maven的多框架和多视图融合技术(Struts1、Struts2、Spring、SpringMVC、Hibernate、Ibatis、MyBatis、Spring Data JPA、DWR)

雪山飞鹄 — Tue, 25 Sep 2012 03:40:00 GMT

该项目基于maven3.0构建的，项目中融合了Struts1、Struts2、Spring、SpringMVC、Hibernate、Ibatis、MyBatis、Spring Data JPA、Spring JDBC、Spring DWR。页面展现这里使用Struts1、Struts2、SpringMVC（jsp视图、velocity视图、freemarker视图、pdf视图、excel视图、xml视图、json视图等）。是一个综合性行的项目。该项目后期会陆续集成Spring的一些好的框架进来比如说Spring Web Flow、Spring Security 、Jbpm、WebService、Compass、Solr、nutch等。总之是一个综合性的项目。该项目不处理业务，主要是把目前自己工作中用到过的各种框架糅合到一个项目中。纯粹是一个jee框架的糅合，主要是介绍各种技术。

介绍下目前使用的各个框架的版本信息

Struts1 1.3.10

Struts2 2.3.8

Spring 3.2.0.RELEASE

Hibernate 4.2.0.Final

Ibatis 2.3.4.726

MyBatis 3.1.1

Spring Data JPA 1.3.0.RELEASE

DWR 3.0.M1

项目中的持久化框架sql语句的跟踪采用了log4jdbc4结合log4j，在控制台可以看到完整的sql语句。

该项目中使用到的技术均与Spring已集成。除了DWR与Spring集成使用xml文件中配置bean外其他的bean均使用注解完善。每一个与数据库有关的都有事务处理。

项目结构图

项目托管SVN地址：http://maven-framework-project.googlecode.com/svn/trunk/ (限于大陆google code 不稳定,导致经常无法访问,该地址已不在同步,建议使用github地址)
项目托管GitHub地址：https://github.com/sxyx2008/maven-framework-project/（推荐使用）

最后希望有兴趣的朋友可以加入进来，大家一起完善他。把自己的技术分享出来。如有任何问题可以与我联系

联系方式

QQ：184675420

Email：sxyx2008@gmail.com

雪山飞鹄 2012-09-25 11:40 发表评论

Struts2、Spring、Hibernate、Lucene整合Compass实现搜索

雪山飞鹄 — Thu, 26 May 2011 09:02:00 GMT

花时间尝试着写了个Struts2+Spring+Hibernate+Compass+Lucene整合的例子.代码和jar包较多，有兴趣的朋友可以去http://sshcompass.googlecode.com/svn/trunk/将工程捡下来。希望和大家一起探讨Compass这个框架。

雪山飞鹄 2011-05-26 17:02 发表评论

持久化框架系列配置总结

雪山飞鹄 — Mon, 18 Oct 2010 13:41:00 GMT

在这一年多时间里，由于项目多半使用的是jdbc，很少使用到Hibernate、JPA、Ibatis等持久层框架。最多使用上spring的jdbcTemplate 久而久之，之前学习的这些持久层框架的映射配置忘的差不多了。借近期有时间，抽空复习了下以上三个持久层框架。现将项目中常用的映射关系的关联配置整理如下:
JPA:

JPA主键双向关联一对一映射

 JPA外键双向关联一对一映射

JPA双向关联多对一映射

JPA多对多双向关联

Hibernate:

Hibernate一对一主键双向关联映射(xml配置)

Hibernate一对一主键双向关联映射(Annotation配置)

Hibernate一对一外键双向关联(xml配置篇)

Hibernate一对一外键双向关联(Annotation配置篇)

Hibernate多对一双向关联(xml配置)

Hibernate多对一双向关联(Annotation配置)

Hibernate多对多双向关联(xml配置)

Hibernate多对多双向关联(Annotation配置)

使用Xdoclet和Ant构建Hibernate映射和配置文件

使用Xdoclet和Ant构建Hibernate映射和配置文件

Ibatis
使用ibatis完成持久化工作

ibatis陆续更新中。。。。。期待下篇ibatis多对一双向关联映射

雪山飞鹄 2010-10-18 21:41 发表评论

Hibernate多对多双向关联(Annotation配置)

雪山飞鹄 — Mon, 18 Oct 2010 13:15:00 GMT

Role.java

package com.many2many.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name="roles",catalog="Hibernate_Many2Many")
public class Role {

    private int id;
    private String name;
    private Set<User> users;
    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @ManyToMany(mappedBy="roles",cascade=CascadeType.ALL)
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

}

User.java

package com.many2many.bean;

import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.Table;

@Entity
@Table(name="users",catalog="Hibernate_Many2Many")
public class User {

    private int id;
    private String name;
    private Set<Role> roles;
    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @ManyToMany(cascade=CascadeType.ALL)
    @JoinTable(
            name="user_role",
            joinColumns=@JoinColumn(name="user_id"),
            inverseJoinColumns=@JoinColumn(name="role_id")
    )
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

}

导出的sql

create table Hibernate_Many2Many.roles (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table Hibernate_Many2Many.users (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table user_role (
        user_id integer not null,
        role_id integer not null,
        primary key (user_id, role_id)
    )

    alter table user_role
        add index FK143BF46ADA6B394F (role_id),
        add constraint FK143BF46ADA6B394F
        foreign key (role_id)
        references Hibernate_Many2Many.roles (id)

    alter table user_role
        add index FK143BF46A7F95FD2F (user_id),
        add constraint FK143BF46A7F95FD2F
        foreign key (user_id)
        references Hibernate_Many2Many.users (id)

测试代码

@Test
    public void insert(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            User user=new User();
            user.setName("张三");

            Role role=new Role();
            role.setName("管理员");
            Set<Role> roles=new HashSet<Role>();
            roles.add(role);
            user.setRoles(roles);

            session.persist(user);

            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            transaction.rollback();
        }
    }


    @Test
    public void select(){
        Session session=HibernateSessionFactory.getSession();
        User user=(User) session.get(User.class, 1);
        System.out.println(user.getName());
        Set<Role> roles=user.getRoles();
        for (Iterator<Role> iterator = roles.iterator(); iterator.hasNext();) {
            Role role = (Role) iterator.next();
            System.out.println(role.getName());
        }
    }

雪山飞鹄 2010-10-18 21:15 发表评论

Hibernate多对多双向关联(xml配置)

雪山飞鹄 — Mon, 18 Oct 2010 13:06:00 GMT

Role.java

package com.many2many.bean;

import java.util.Set;

public class Role {

    private int id;
    private String name;
    private Set<User> users;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<User> getUsers() {
        return users;
    }
    public void setUsers(Set<User> users) {
        this.users = users;
    }

}

User.java

package com.many2many.bean;

import java.util.Set;

public class User {

    private int id;
    private String name;
    private Set<Role> roles;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Role> getRoles() {
        return roles;
    }
    public void setRoles(Set<Role> roles) {
        this.roles = roles;
    }

}

映射文件
Role.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.many2many.bean">
        <class name="Role" table="roles" catalog="Hibernate_Many2Many">
            <id name="id" column="id">
                <generator class="native"/>
            id>
            <property name="name" column="name"/>
            <set name="users" table="user_role" cascade="all">
                <key>
                    <column name="role_id"/>
                key>
                <many-to-many column="user_id" class="User"/>
            set>
        class>
    hibernate-mapping>

User.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.many2many.bean">
        <class name="User" table="users" catalog="Hibernate_Many2Many">
            <id name="id" column="id">
                <generator class="native"/>
            id>
            <property name="name" column="name"/>
            <set name="roles" table="user_role" cascade="all">
                <key>
                    <column name="user_id"/>
                key>
                <many-to-many column="role_id" class="Role"/>
            set>
        class>
    hibernate-mapping>

导出的sql

create table Hibernate_Many2Many.roles (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table Hibernate_Many2Many.users (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table user_role (
        role_id integer not null,
        user_id integer not null,
        primary key (user_id, role_id)
    )

    alter table user_role
        add index FK143BF46ADA6B394F (role_id),
        add constraint FK143BF46ADA6B394F
        foreign key (role_id)
        references Hibernate_Many2Many.roles (id)

    alter table user_role
        add index FK143BF46A7F95FD2F (user_id),
        add constraint FK143BF46A7F95FD2F
        foreign key (user_id)
        references Hibernate_Many2Many.users (id)

测试代码

雪山飞鹄 2010-10-18 21:06 发表评论

Hibernate多对一双向关联(Annotation配置)

雪山飞鹄 — Mon, 18 Oct 2010 07:46:00 GMT

Department.java

package com.many2one.bean;

import java.util.Set;

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

@Entity
@Table(name="department",catalog="Hibernate_Many2One")
public class Department {

    private int id;
    private String name;
    private Set<Employee> sets;
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToMany(mappedBy="department")
    public Set<Employee> getSets() {
        return sets;
    }
    public void setSets(Set<Employee> sets) {
        this.sets = sets;
    }

}

Employee.java

package com.many2one.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

@Entity
@Table(name="employee",catalog="Hibernate_Many2One")
public class Employee {

    private int id;
    private String name;
    private Department department;
    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @ManyToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="deptid")
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }


}

导出的sql

create table Hibernate_Many2One.department (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table Hibernate_Many2One.employee (
        id integer not null auto_increment,
        name varchar(255),
        deptid integer,
        primary key (id)
    )

    alter table Hibernate_Many2One.employee
        add index FK4722E6AE3829E242 (deptid),
        add constraint FK4722E6AE3829E242
        foreign key (deptid)
        references Hibernate_Many2One.department (id)

测试代码

@Test
    public void insert(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            Department department=new Department();
            department.setName("软件测试部");
            Employee employee=new Employee();
            employee.setName("张三");
            employee.setDepartment(department);
            session.save(employee);
            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }


    @Test
    public void select(){
        Session session=HibernateSessionFactory.getSession();
        try {
            Employee employee=(Employee) session.get(Employee.class, 1);
            System.out.println(employee.getName());
            System.out.println(employee.getDepartment().getName());
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

雪山飞鹄 2010-10-18 15:46 发表评论

Hibernate多对一双向关联(xml配置)

雪山飞鹄 — Mon, 18 Oct 2010 07:40:00 GMT

Department.java

package com.many2one.bean;

import java.util.Set;

public class Department {

    private int id;
    private String name;
    private Set<Employee> sets;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Set<Employee> getSets() {
        return sets;
    }
    public void setSets(Set<Employee> sets) {
        this.sets = sets;
    }

}

Employee.java

package com.many2one.bean;

public class Employee {

    private int id;
    private String name;
    private Department department;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Department getDepartment() {
        return department;
    }
    public void setDepartment(Department department) {
        this.department = department;
    }


}

映射文件
Department.hbm.xml

Employee.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.many2one.bean">
        <class name="Employee" table="employee" catalog="Hibernate_Many2One">
            <id name="id" column="id">
                <generator class="native"/>
            id>
            <property name="name" column="name"/>
            <many-to-one name="department" column="deptid" cascade="all" />
        class>
    hibernate-mapping>

导出的sql

测试代码

@Test
    public void insert(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            Department department=new Department();
            department.setName("软件测试部");
            Employee employee=new Employee();
            employee.setName("张三");
            employee.setDepartment(department);
            session.save(employee);
            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }


    @Test
    public void select(){
        Session session=HibernateSessionFactory.getSession();
        try {
            Employee employee=(Employee) session.get(Employee.class, 1);
            System.out.println(employee.getName());
            System.out.println(employee.getDepartment().getName());
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

雪山飞鹄 2010-10-18 15:40 发表评论

Hibernate一对一外键双向关联(Annotation配置篇)

雪山飞鹄 — Mon, 18 Oct 2010 06:29:00 GMT

Husband.java

package com.one2one.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="husband",catalog="Hibernate_One2One_fk")
public class Husband {

    private int id;
    private String name;
    private Wife wife;
    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToOne(cascade=CascadeType.ALL,mappedBy="husband")
    public Wife getWife() {
        return wife;
    }
    public void setWife(Wife wife) {
        this.wife = wife;
    }

}

Wife.java

package com.one2one.bean;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
import javax.persistence.Table;

@Entity
@Table(name="wife",catalog="Hibernate_One2One_fk")
public class Wife {

    private int id;
    private String name;
    private Husband husband;
    @Id
    @Column(name="id")
    @GeneratedValue(strategy=GenerationType.AUTO)
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToOne(cascade=CascadeType.ALL)
    @JoinColumn(name="husband_id")
    public Husband getHusband() {
        return husband;
    }
    public void setHusband(Husband husband) {
        this.husband = husband;
    }

}

导出的sql

create table Hibernate_One2One_fk.husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table Hibernate_One2One_fk.wife (
        id integer not null auto_increment,
        name varchar(255),
        husband_id integer,
        primary key (id)
    )

    alter table Hibernate_One2One_fk.wife
        add index FK37AF119039AEDD (husband_id),
        add constraint FK37AF119039AEDD
        foreign key (husband_id)
        references Hibernate_One2One_fk.husband (id)

测试代码

@Test
    public void save(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            Husband husband=new Husband();
            husband.setName("张三");
            session.save(husband);
            Wife wife=new Wife();
            wife.setName("如花");
            wife.setHusband(husband);
            session.save(wife);
            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
        }
    }

    @Test
    public void select(){
        Session session=HibernateSessionFactory.getSession();
        Husband husband=(Husband) session.get(Husband.class, 1);
        System.out.println(husband.getName());
        System.out.println(husband.getWife().getName());
    }

雪山飞鹄 2010-10-18 14:29 发表评论

Hibernate一对一外键双向关联(xml配置篇)

雪山飞鹄 — Mon, 18 Oct 2010 06:17:00 GMT

Husband.java

package com.one2one.bean;

public class Husband {

    private int id;
    private String name;
    private Wife wife;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Wife getWife() {
        return wife;
    }
    public void setWife(Wife wife) {
        this.wife = wife;
    }

}

Wife.java

package com.one2one.bean;

public class Wife {

    private int id;
    private String name;
    private Husband husband;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Husband getHusband() {
        return husband;
    }
    public void setHusband(Husband husband) {
        this.husband = husband;
    }

}

映射文件
Husband.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.one2one.bean">
        <class name="Husband" table="husband" catalog="Hibernate_One2One_fk">
            <id name="id" column="id">
                <generator class="native"/>
            id>
            <property name="name" column="name"/>
            <one-to-one name="wife" class="Wife" property-ref="husband"/>
        class>
    hibernate-mapping>

property-ref后的husband为Wife中定义的husband属性
Wife.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.one2one.bean">
        <class name="Wife" table="wife" catalog="Hibernate_One2One_fk">
            <id name="id" column="id">
                <generator class="native"/>
            id>
            <property name="name" column="name"/>
            <many-to-one name="husband" column="husband_id" unique="true" />
        class>
    hibernate-mapping>

many-to-one的作用是在wife表中生成一个外键husband_id,且唯一,并参照husband表中的主键
用hibernate的hbm2ddl导出的sql

create table Hibernate_One2One_fk.husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table Hibernate_One2One_fk.wife (
        id integer not null auto_increment,
        name varchar(255),
        husband_id integer unique,
        primary key (id)
    )

    alter table Hibernate_One2One_fk.wife
        add index FK37AF119039AEDD (husband_id),
        add constraint FK37AF119039AEDD
        foreign key (husband_id)
        references Hibernate_One2One_fk.husband (id)

测试示例

雪山飞鹄 2010-10-18 14:17 发表评论

Caused by: org.hibernate.PersistentObjectException: detached entity passed to persist:

雪山飞鹄 — Fri, 15 Oct 2010 05:30:00 GMT

Caused by: org.hibernate.PersistentObjectException: detached entity passed to persist:
此异常多出现在Hibernate、JPA级联映射中,在级联保存时频发
从异常信息不难看出，在进行持久化的时候引用了一个未持久化的对象
或者确定给对象已被持久化了,当再次去引用时，仍包此错误，那么只有一种可能，就是在配置文件里面级联配置的不正确尝试把cascade = CascadeType.ALL 改成 cascade=CascadeType.REFRESH 测一下看看。(适用于Hibernate注解或JPA的级联映射)

雪山飞鹄 2010-10-15 13:30 发表评论

Hibernate一对一主键双向关联映射(Annotation配置)

雪山飞鹄 — Thu, 14 Oct 2010 02:28:00 GMT

实体
Husband

package com.hibernate.one2one.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

@Entity
@Table(name="husband")
public class Husband {

    private int id;
    private String name;
    private Wife wife;
    @Id
    @GeneratedValue(strategy=GenerationType.AUTO)
    @Column(name="id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToOne
    @PrimaryKeyJoinColumn
    public Wife getWife() {
        return wife;
    }
    public void setWife(Wife wife) {
        this.wife = wife;
    }

}

Wife

package com.hibernate.one2one.bean;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.OneToOne;
import javax.persistence.PrimaryKeyJoinColumn;
import javax.persistence.Table;

@Entity
@Table(name="wife")
public class Wife {

    private int id;
    private String name;
    private Husband husband;
    @Id
    @Column(name="id")
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @Column(name="name")
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @OneToOne(optional=false)
    @PrimaryKeyJoinColumn
    public Husband getHusband() {
        return husband;
    }
    public void setHusband(Husband husband) {
        this.husband = husband;
    }

}

温馨提示:注意wife.java里面的@OneToOne(optional=false) optional=false 属性会在wife这端添加一个外键约束
添加上上述属性使用hbm2ddl导出表，打印出的sql语句

alter table wife
        drop
        foreign key FK37AF11D67CB035

    drop table if exists husband

    drop table if exists wife

    create table husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table wife (
        id integer not null,
        name varchar(255),
        primary key (id)
    )

    alter table wife
        add index FK37AF11D67CB035 (id),
        add constraint FK37AF11D67CB035
        foreign key (id)
        references husband (id)

@Test
    public void insert(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            Husband husband=new Husband();
            husband.setName("小明");
            session.save(husband);
            Wife wife=new Wife();
            wife.setName("如花");
            wife.setHusband(husband);
            wife.setId(husband.getId());
            session.save(wife);
            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            transaction.rollback();
        }
    }

温馨提醒:此处必须同时设置
wife.setHusband(husband);
wife.setId(husband.getId());
否则报org.hibernate.exception.ConstraintViolationException: Could not execute JDBC batch update

示例程序

雪山飞鹄 2010-10-14 10:28 发表评论

Hibernate一对一主键双向关联映射(xml配置)

雪山飞鹄 — Thu, 14 Oct 2010 02:01:00 GMT

alter table wife
drop
foreign key FK37AF11D67CB035

drop table if exists husband

drop table if exists wife

    create table husband (
        id integer not null auto_increment,
        name varchar(255),
        primary key (id)
    )

    create table wife (
        id integer not null,
        name varchar(255),
        primary key (id)
    )

    alter table wife
        add index FK37AF11D67CB035 (id),
        add constraint FK37AF11D67CB035
        foreign key (id)
        references husband (id)

实体
Husband

private int id;
private String name;
private Wife wife;

Wife
private int id;
private String name;
private Husband husband;

Husband.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.hibernate.one2one.bean">
        <class name="Husband" table="husband">
            <id name="id" column="id">
                <generator class="native">generator>
            id>
            <property name="name">property>
            <one-to-one name="wife" cascade="all" class="Wife">one-to-one>
        class>
    hibernate-mapping>

Wife.hbm.xml

xml version="1.0" encoding="UTF-8"?>
DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
    <hibernate-mapping package="com.hibernate.one2one.bean">
        <class name="Wife" table="wife">
            <id name="id" column="id">
                <generator class="foreign">
                    <param name="property">husbandparam>
                generator>
            id>
            <property name="name">property>
            <one-to-one name="husband" constrained="true">one-to-one>
        class>
    hibernate-mapping>

@Test
    public void insert(){
        Session session=HibernateSessionFactory.getSession();
        Transaction transaction=session.beginTransaction();
        try {
            transaction.begin();
            Husband husband=new Husband();
            husband.setName("小明");
            session.save(husband);
            Wife wife=new Wife();
            wife.setName("如花");
            wife.setHusband(husband);
            session.save(wife);
            transaction.commit();
        } catch (HibernateException e) {
            e.printStackTrace();
            transaction.rollback();
        }
    }

示例程序

雪山飞鹄 2010-10-14 10:01 发表评论

Hibernate3.5之常见异常解决方案

雪山飞鹄 — Sat, 09 Oct 2010 02:42:00 GMT

java.lang.NoSuchMethodError: javax.persistence.OneToOne.orphanRemoval()Z
ejb3的jar包与JPA包冲突 ejb3的jar包删除就OK了

java.lang.NoClassDefFoundError: javax/persistence/Cacheable
错误原因，javax.persistence.Cacheable 是 JPA 2.0 规范中的东西！
支持 JPA 2 的 Hibernate 实现 3.5 版目前还处于CR2 版本之中，还没有正式发布。
需要在加入hibernate-distribution-3.5.0-Final\lib\jpa目录下的hibernate-jpa-2.0-api-1.0.0.Final.jar

java.lang.NoClassDefFoundError: org/slf4j/impl/StaticLoggerBinder
缺少slf4j-nop-1.5.8.jar

雪山飞鹄 2010-10-09 10:42 发表评论

使用Xdoclet和Ant构建Hibernate映射和配置文件

雪山飞鹄 — Thu, 30 Sep 2010 08:03:00 GMT

摘要: 使用Xdoclet和Ant构建Hibernate映射和配置文件温馨提示：由于文档中含大量图片，这里不方便一一上传建议下载本文电子版文档阅读 Xdoclet.pdf 本文工程下载 svn地址:http://xdocletdemo.googlecode.com/svn/trunk/ 功能描述: &... 阅读全文

雪山飞鹄 2010-09-30 16:03 发表评论

JPA注解

雪山飞鹄 — Tue, 20 Jul 2010 02:13:00 GMT

1、@Entity(name="EntityName")

必须,name为可选,对应数据库中一的个表

2、@Table(name="",catalog="",schema="")

可选,通常和@Entity配合使用,只能标注在实体的class定义处,表示实体对应的数据库表的信息

name:可选,表示表的名称.默认地,表名和实体名称一致,只有在不一致的情况下才需要指定表名

catalog:可选,表示Catalog名称,默认为Catalog("").

schema:可选,表示Schema名称,默认为Schema("").

3、@id

必须

@id定义了映射到数据库表的主键的属性,一个实体只能有一个属性被映射为主键.置于getXxxx()前.

4、@GeneratedValue(strategy=GenerationType,generator="")

可选

strategy:表示主键生成策略,有AUTO,INDENTITY,SEQUENCE 和 TABLE 4种,分别表示让ORM框架自动选择,

根据数据库的Identity字段生成,根据数据库表的Sequence字段生成,以有根据一个额外的表生成主键,默认为AUTO

generator:表示主键生成器的名称,这个属性通常和ORM框架相关,例如,Hibernate可以指定uuid等主键生成方式.

示例:

@Id

@GeneratedValues(strategy=StrategyType.SEQUENCE)

public int getPk() {

return pk;

}

5、@Basic(fetch=FetchType,optional=true)

可选

@Basic表示一个简单的属性到数据库表的字段的映射,对于没有任何标注的getXxxx()方法,默认即为@Basic

fetch: 表示该属性的读取策略,有EAGER和LAZY两种,分别表示主支抓取和延迟加载,默认为EAGER.

optional:表示该属性是否允许为null,默认为true

示例:

@Basic(optional=false)

public String getAddress() {

return address;

}

6、@Column

可选

@Column描述了数据库表中该字段的详细定义,这对于根据JPA注解生成数据库表结构的工具非常有作用.

name:表示数据库表中该字段的名称,默认情形属性名称一致

nullable:表示该字段是否允许为null,默认为true

unique:表示该字段是否是唯一标识,默认为false

length:表示该字段的大小,仅对String类型的字段有效

insertable:表示在ORM框架执行插入操作时,该字段是否应出现INSETRT语句中,默认为true

updateable:表示在ORM框架执行更新操作时,该字段是否应该出现在UPDATE语句中,默认为true.对于一经创建就不可以更改的字段,该属性非常有用,如对于birthday字段.

columnDefinition:表示该字段在数据库中的实际类型.通常ORM框架可以根据属性类型自动判断数据库中字段的类型,但是对于Date类型仍无法确定数据库中字段类型究竟是DATE,TIME还是TIMESTAMP.此外,String的默认映射类型为VARCHAR,如果要将String类型映射到特定数据库的BLOB或TEXT字段类型,该属性非常有用.

示例:

@Column(name="BIRTH",nullable="false",columnDefinition="DATE")

public String getBithday() {

return birthday;

}

7、@Transient

可选

@Transient表示该属性并非一个到数据库表的字段的映射,ORM框架将忽略该属性.

如果一个属性并非数据库表的字段映射,就务必将其标示为@Transient,否则,ORM框架默认其注解为@Basic

示例:

//根据birth计算出age属性

@Transient

public int getAge() {

return getYear(new Date()) - getYear(birth);

}

8、@ManyToOne(fetch=FetchType,cascade=CascadeType)

可选

@ManyToOne表示一个多对一的映射,该注解标注的属性通常是数据库表的外键

optional:是否允许该字段为null,该属性应该根据数据库表的外键约束来确定,默认为true

fetch:表示抓取策略,默认为FetchType.EAGER

cascade:表示默认的级联操作策略,可以指定为ALL,PERSIST,MERGE,REFRESH和REMOVE中的若干组合,默认为无级联操作

targetEntity:表示该属性关联的实体类型.该属性通常不必指定,ORM框架根据属性类型自动判断targetEntity.

示例:

//订单Order和用户User是一个ManyToOne的关系

//在Order类中定义

@ManyToOne()

@JoinColumn(name="USER")

public User getUser() {

return user;

}

9、@JoinColumn

可选

@JoinColumn和@Column类似,介量描述的不是一个简单字段,而一一个关联字段,例如.描述一个@ManyToOne的字段.

name:该字段的名称.由于@JoinColumn描述的是一个关联字段,如ManyToOne,则默认的名称由其关联的实体决定.

例如,实体Order有一个user属性来关联实体User,则Order的user属性为一个外键,

其默认的名称为实体User的名称+下划线+实体User的主键名称

示例:

见@ManyToOne

10、@OneToMany(fetch=FetchType,cascade=CascadeType)

可选

@OneToMany描述一个一对多的关联,该属性应该为集体类型,在数据库中并没有实际字段.

fetch:表示抓取策略,默认为FetchType.LAZY,因为关联的多个对象通常不必从数据库预先读取到内存

cascade:表示级联操作策略,对于OneToMany类型的关联非常重要,通常该实体更新或删除时,其关联的实体也应当被更新或删除

例如:实体User和Order是OneToMany的关系,则实体User被删除时,其关联的实体Order也应该被全部删除

示例:

@OneTyMany(cascade=ALL)

public List getOrders() {

return orders;

}

11、@OneToOne(fetch=FetchType,cascade=CascadeType)

可选

@OneToOne描述一个一对一的关联

fetch:表示抓取策略,默认为FetchType.LAZY

cascade:表示级联操作策略

示例:

@OneToOne(fetch=FetchType.LAZY)

public Blog getBlog() {

return blog;

}

12、@ManyToMany

可选

@ManyToMany 描述一个多对多的关联.多对多关联上是两个一对多关联,但是在ManyToMany描述中,中间表是由ORM框架自动处理

targetEntity:表示多对多关联的另一个实体类的全名,例如:package.Book.class

mappedBy:表示多对多关联的另一个实体类的对应集合属性名称

示例:

User实体表示用户,Book实体表示书籍,为了描述用户收藏的书籍,可以在User和Book之间建立ManyToMany关联

@Entity

public class User {

private List books;

@ManyToMany(targetEntity=package.Book.class)

public List getBooks() {

return books;

}

public void setBooks(List books) {

this.books=books;

}

@Entity

public class Book {

private List users;

@ManyToMany(targetEntity=package.Users.class, mappedBy="books")

public List getUsers() {

return users;

}

public void setUsers(List users) {

this.users=users;

}

两个实体间相互关联的属性必须标记为@ManyToMany,并相互指定targetEntity属性,

需要注意的是,有且只有一个实体的@ManyToMany注解需要指定mappedBy属性,指向targetEntity的集合属性名称

利用ORM工具自动生成的表除了User和Book表外,还自动生成了一个User_Book表,用于实现多对多关联

13、@MappedSuperclass

可选

@MappedSuperclass可以将超类的JPA注解传递给子类,使子类能够继承超类的JPA注解

示例:

@MappedSuperclass

public class Employee() {

....

}

@Entity

public class Engineer extends Employee {

.....

}

@Entity

public class Manager extends Employee {

.....

}

14、@Embedded

可选

@Embedded将几个字段组合成一个类,并作为整个Entity的一个属性.

例如User包括id,name,city,street,zip属性.

我们希望city,street,zip属性映射为Address对象.这样,User对象将具有id,name和address这三个属性.

Address对象必须定义为@Embededable

示例:

@Embeddable

public class Address {city,street,zip}

@Entity

public class User {

@Embedded

public Address getAddress() {

..........

}

Hibernate验证注解

注解

适用类型

说明

示例

@Pattern

String

通过正则表达式来验证字符串

@attern(regex=”[a-z]{6}”)

@Length

String

验证字符串的长度

@length(min=3,max=20)

@Email

String

验证一个Email地址是否有效

@email

@Range

Long

验证一个整型是否在有效的范围内

@Range(min=0,max=100)

@Min

Long

验证一个整型必须不小于指定值

@Min(value=10)

@Max

Long

验证一个整型必须不大于指定值

@Max(value=20)

@Size

集合或数组

集合或数组的大小是否在指定范围内

@Size(min=1,max=255)

以上每个注解都可能性有一个message属性，用于在验证失败后向用户返回的消息，还可以三个属性上使用多个注解

雪山飞鹄 2010-07-20 10:13 发表评论

Hibernate org.hibernate.PropertyAccessException: exception setting property value with CGLIB异常分析及处理

雪山飞鹄 — Wed, 25 Nov 2009 09:56:00 GMT

Hibernate org.hibernate.PropertyAccessException: exception setting property value with CGLIB异常分析及处理

异常信息：

Exception in thread "main" org.hibernate.PropertyAccessException: exception setting property value with CGLIB (set hibernate.cglib.use_reflection_optimizer=false for more info) setter of com.dl.bean.Employee.setDepartment

at org.hibernate.tuple.PojoEntityTuplizer.setPropertyValuesWithOptimizer(PojoEntityTuplizer.java:215)

at org.hibernate.tuple.PojoEntityTuplizer.setPropertyValues(PojoEntityTuplizer.java:185)

at org.hibernate.persister.entity.AbstractEntityPersister.setPropertyValues(AbstractEntityPersister.java:3232)

at org.hibernate.engine.TwoPhaseLoad.initializeEntity(TwoPhaseLoad.java:129)

at org.hibernate.loader.Loader.initializeEntitiesAndCollections(Loader.java:842)

at org.hibernate.loader.Loader.doQuery(Loader.java:717)

at org.hibernate.loader.Loader.doQueryAndInitializeNonLazyCollections(Loader.java:224)

at org.hibernate.loader.Loader.doList(Loader.java:2145)

at org.hibernate.loader.Loader.listIgnoreQueryCache(Loader.java:2029)

at org.hibernate.loader.Loader.list(Loader.java:2024)

at org.hibernate.loader.hql.QueryLoader.list(QueryLoader.java:375)

at org.hibernate.hql.ast.QueryTranslatorImpl.list(QueryTranslatorImpl.java:308)

at org.hibernate.engine.query.HQLQueryPlan.performList(HQLQueryPlan.java:153)

at org.hibernate.impl.SessionImpl.list(SessionImpl.java:1106)

at org.hibernate.impl.QueryImpl.list(QueryImpl.java:79)

at com.dl.test.EmployeeTest.main(EmployeeTest.java:26)

Caused by: net.sf.cglib.beans.BulkBeanException: com.dl.bean.Employee cannot be cast to com.dl.bean.Department

at com.dl.bean.Employee$$BulkBeanByCGLIB$$a415f505.setPropertyValues()

at org.hibernate.tuple.PojoEntityTuplizer.setPropertyValuesWithOptimizer(PojoEntityTuplizer.java:212)

... 15 more

Caused by: java.lang.ClassCastException: com.dl.bean.Employee cannot be cast to com.dl.bean.Department

... 17 more

遇此异常很老火，当然第一件事就是在google上baidu一把看能解决吧!

google上baidu结果如下：

查询结果中包含null的值，对于一些数字或boolean包含null，定义该项时必须使用wrapper类型，而不能是primitive类型，例如使用Integer而不能是int,Boolean而不能是boolean否则会抛出exception

结论是：对于属性在set/get时,属性值为null而出现该异常

我对此种说法不敢苟同，既然google上有这种说法相比就有它存在的道理。

从上述语句中我们得出结论：在写pojo类时最好选用包装类而不使用java中的基本数据类型，以免产生一些莫名其妙的错误(建议使用5.0以上的jdk版本)大家一直认为java是面向对象的语言，这句话在jdk1.4以前是有分歧的，大家都知道java中8个基本数据类型不是对象，所以这么说还不够严谨，直到jdk5.0的诞生，这句话才勉强成立。我想这也是sun公为什么极力推荐使用包装类的缘故。

看来还得自己分析这个异常，那么首先从映射文件及pojo类来下手

Java代码：

publicclass Employee {

private Integer id;

private String empname;

private Integer empage;

private String context;

private Integer deptid;

private Department department=new Department();

//省略set()、get()方法

}

<hibernate-mapping package="com.dl.bean">

id>

<many-to-one name="department" column="deptid" cascade="all" class="Employee" /> //此处为错误的根源，这个错误很隐蔽，不仔细检查很难发现

class>

hibernate-mapping>

不知道至此大家发现错误了没，经过本人仔细检查以及分析以上pojo类及映射文件，发现在标签中class属性配置出错了，正确的配置应为：

<many-to-one name="department" column="deptid" cascade="all" class="Department" />,到此问题彻底解决了,没什么技术含量,只是记下来,防止更多人走冤枉路

雪山飞鹄 2009-11-25 17:56 发表评论

Spring 结合Hibernate 配置 C3P0 连接池

雪山飞鹄 — Mon, 16 Nov 2009 07:08:00 GMT

摘要: applicationContext.xml 文件：雪山飞鹄 2009-11-16 15:08 发表评论

attempt to create saveOrUpdate event with null entity

雪山飞鹄 — Mon, 19 Oct 2009 03:39:00 GMT

今天在写struts2 save的时候报了这么一个异常

java.lang.IllegalArgumentException: attempt to create saveOrUpdate event with null entity

at org.hibernate.event.SaveOrUpdateEvent.(SaveOrUpdateEvent.java:40)

at org.hibernate.event.SaveOrUpdateEvent.(SaveOrUpdateEvent.java:23)

at org.hibernate.impl.SessionImpl.save(SessionImpl.java:518)

at org.hibernate.impl.SessionImpl.save(SessionImpl.java:514)

从上面的异常信息可以看出是在Hibernate进行save的时候检测到bean为null

1) 大致从这几个方面来分析原因：

2) Hibernate(*.hbm.xml)映射文件是否错误

3) DAO层代码是否错误

4) 检查Action及视图层jsp页面等

从上面几个逐个检查后得出的结论为第四条

首先看Action中的代码

private Employee employee;

public Employee getEmployee() {

returnemployee;

}

publicvoid setEmployee(Employee employee) {

this.employee = employee;

}

这里employee是我们观察的重点

再看jsp中的代码

<s:form action="saveEmployee.action">

<s:textfield name="empName" label="empName">s:textfield>

<s:textfield name="age" label="age">s:textfield>

<s:textfield name="sex" label="sex">s:textfield>

<s:textfield name="context" label="context">s:textfield>

<s:submit value="注册" theme="simple">s:submit>

<s:reset value="取消" theme="simple">s:reset>

s:form>

大家注意中name属性的值

很显然错误发生在此处修改如下即可：

<s:form action="saveEmployee.action">

<s:textfield name="employee.empName" label="empName">s:textfield>

<s:textfield name="employee.age" label="age">s:textfield>

<s:textfield name="employee.sex" label="sex">s:textfield>

<s:textfield name="employee.context" label="context" value="">s:textfield>

<s:submit value="注册" theme="simple">s:submit>

<s:reset value="取消" theme="simple">s:reset>

s:form>

由此我们得出的结论是：

在jsp页面中一定要保持页面中各个控件的name属性与Action中模型驱动对象的名字一致否则就会报错

雪山飞鹄 2009-10-19 11:39 发表评论