使用JPA注解配置ORM实体类

在上一篇《自定义配置LINQ的ORM实体类》中，收到某位博友的指正，改变了自己对某些东西的看法。其中最重要的一点便是：不轻易评判他人，专心做好自己。望与大家共勉。

今天使用做一个最简单的Demo，为自己和初学者提供一个参考。但是各种注解的说明和具体使用环境，还需每个人自己进行细致学习。

数据库还是使用上一章的，表就是简单的学生和班级。

首先建立实体类  班级

import java.io.Serializable;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.Id;
import javax.persistence.OneToMany;
import javax.persistence.Table;


@Entity
@Table(name="MyClass")
public class MyClass implements Serializable {

    /**
     * 序列化ID
*/
    private static final long serialVersionUID = 1L;

    /**
     * 班级编号
     * @Id 表示主键
     * @Column 设置相对应的列参数
     * 因为不是自增长的主键，所以使用 GeneratedValue 注解会报错
*/
    @Id
    @Column(name="class_no",nullable=false)
    private String classNo;
    
    @Column(name="class_name",nullable=false)
    private String className;
    
    /**
     * 设置一对多关系，表示该是主键表
     * mappedBy 表示被映射在属性在多方实体中的字段，
     * cascade 表示维护关系由谁来进行，可以进行哪些维护
*/
    @OneToMany(targetEntity=Student.class,mappedBy="myClass",fetch=FetchType.EAGER,cascade=CascadeType.ALL)
    private Set<Student> student;
    
    
    public Set<Student> getStudent() {
        return student;
    }

    public void setStudent(Set<Student> student) {
        this.student = student;
    }

    public String getClassNo() {
        return classNo;
    }

    public void setClassNo(String classNo) {
        this.classNo = classNo;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    
    
}

学生

import java.io.Serializable;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.Table;


@Entity
@Table(name="MyStudent")
public class Student implements Serializable {

    /**
     * 
*/
    private static final long serialVersionUID = 4575350354658352861L;
    
    @Id
    @Column(name="stu_no",nullable=false)
    private String stuNo;
    @Column(name="stu_name",nullable=false)
    private String stuName;
    
    @Column(name="stu_age")
    private Integer stuAge;
    
    @Column(name="stu_address")
    private String stuAddress;
    
    /**
     * 学生对应的班级 
     * JoinColumn中的name表示外键中的外键字段，
     * 之前配置了referencedColumnName 属性，结果出现了 错误
*/
    @ManyToOne(targetEntity=MyClass.class)
    @JoinColumn(name="stu_class_no",nullable= false)
    private MyClass myClass;
    
    public MyClass getMyClass() {
        return myClass;
    }
    public void setMyClass(MyClass myClass) {
        this.myClass = myClass;
    }
    
    
    public String getStuNo() {
        return stuNo;
    }
    public void setStuNo(String stuNo) {
        this.stuNo = stuNo;
    }
    public String getStuName() {
        return stuName;
    }
    public void setStuName(String stuName) {
        this.stuName = stuName;
    }
    public Integer getStuAge() {
        return stuAge;
    }
    public void setStuAge(Integer stuAge) {
        this.stuAge = stuAge;
    }
    public String getStuAddress() {
        return stuAddress;
    }
    public void setStuAddress(String stuAddress) {
        this.stuAddress = stuAddress;
    }
    
    

}

然后是一个DAO公共类

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;
import javax.persistence.Query;

public class JpaCommonDao<T> {
private Class<T> clazz = null;
    
    protected JpaCommonDao(Class<T> clazz){
        this.clazz = clazz;
    }
    
    public JpaCommonDao(){
        ParameterizedType type =  (ParameterizedType)this.getClass().getGenericSuperclass();
        clazz = (Class<T>)(type.getActualTypeArguments()[0]);
    }

    protected EntityManager getEm()
    {
        EntityManagerFactory factory = Persistence.createEntityManagerFactory("ntc-mssql");
        EntityManager em = factory.createEntityManager();
        return em;
    }
    
    protected void add(T item) 
    {
        EntityManager em = this.getEm();
        EntityTransaction tran= em.getTransaction();
        tran.begin();
        try
        {
            em.persist(item);
            tran.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            tran.rollback();
        }
        em.close();
        
        
    }
    
    
    protected void update(T item)
    {
        EntityManager em = this.getEm();
        EntityTransaction tran= em.getTransaction();
        tran.begin();
        try
        {
            em.refresh(item);
            tran.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            tran.rollback();
        }
        em.close();
    }


    protected void delete(Serializable id) {
        EntityManager em = this.getEm();
        EntityTransaction tran= em.getTransaction();
        tran.begin();
        try
        {
            T item = em.find(clazz, id);
            if(null == item)
                return ;
            em.remove(item);
            tran.commit();
        }
        catch (Exception e) {
            e.printStackTrace();
            tran.rollback();
        }
        em.close();
        
    }

    protected T getObj(Serializable id) {
        EntityManager em = this.getEm();
        T item = null;
        item = em.find(clazz, id);
        em.close();
        return item;
    }

    
    protected List<T> findList(String jpql)
    {
        EntityManager em = this.getEm();
        Query query = em.createQuery(jpql);
        List<T> list = query.getResultList();
        em.close();
        return list;
    }
}

数据访问类

import java.util.List;
import com.demo.entity.MyClass;


public  class MyClassDao extends JpaCommonDao<MyClass> {
    
    public void add(MyClass cla ) 
    {
        super.add(cla);
    }
    
    public void update(MyClass cla){
        super.update(cla);
    }
    
    public void delete(String id){
        super.delete(id);
    }
    
    public MyClass getClass(String id){
        return super.getObj(id);
    }
    

    /**
     * 根据主键获取班级信息
     * @param id 主键ClassNo
     * @return 
*/
    public MyClass queryClass(String id) {
        String jpql="SELECT c FROM MyClass c left join fetch c.student WHERE c.classNo = "+id;
        List<MyClass> list = super.findList(jpql);
        if(list.size()>0){
            return list.get(0);
        }
        return null;
        
    }
    
    /**
     * 获取批量班级信息
     * @return
*/
    public List<MyClass> queryList()
    {
        String jpql="SELECT c FROM MyClass c left join fetch c.student ";
        
        List<MyClass> list = super.findList(jpql);
        
        if(list.size()>0){
            return list;
        }
        return null;
    }
    
    
}

import java.util.List;

import com.demo.entity.Student;

public  class StudentDao extends JpaCommonDao<Student> {
    
    public void add(Student stu)
    {
        super.add(stu);
    }
    
    public void update(Student stu){
        super.update(stu);
    }
    
    public void delete(String id){
        super.delete(id);
    }
    
    public Student getStudent(String id)
    {
        return super.getObj(id);
    }
    
    public Student queryStuden(String id){
        String jpql="SELECT s FROM Student s left join fetch s.myClass WHERE s.stuNo = "+id;
        List<Student> list = super.findList(jpql);
        if(list.size()>0){
            return list.get(0);
        }
        return null;
    }
    
    public List<Student> getStudensByClassNo(String clsNo){
        String jpql="SELECT s FROM Student s left join fetch s.myClass WHERE s.myClass.classNo = "+clsNo;
        List<Student> list = super.findList(jpql);
        if(list.size()>0){
            return list;
        }
        return null;
    }
}

最后的测试类

public class MyTest {

    
    /**
     * 根据班级编号获得班级信息
*/
    public void getMyClass()
    {
        MyClassDao dao =new MyClassDao(); 
        MyClass cls = dao.getClass("0601");
        System.out.println(cls.getClassName());
    }
    
    /**
     * 添加一个班级
*/
    public  void addClass()
    {
        MyClass cla = new MyClass();
        cla.setClassName("06120班");
        cla.setClassNo("0612");
        cla.setStudent(null);//如果不设定为null的话，是会抛出错误的。因为我在实体类中new 了一次。如果不new一次的话，就不需要
        new MyClassDao().add(cla);
                
    }
    
    /**
     * 添加一个班级和相应学生通过添加班级对象
*/
    @Test
    public  void addClassAndStudentByClass()
    {
        MyClass cla = new MyClass();
        cla.setClassName("0613班");
        cla.setClassNo("0613");
        
        Student stu1 =new Student();
        stu1.setMyClass(cla);
        stu1.setStuName("13肖文斌");
        stu1.setStuNo("061301");
        
        Student stu2 =new Student();
        stu2.setMyClass(cla);
        stu2.setStuName("1302");
        stu2.setStuNo("061303");
        
        Student stu3 =new Student();
        stu3.setMyClass(cla);
        stu3.setStuName("1305");
        stu3.setStuNo("061305");
        
        //因为在班级对象中，设置了维护对方关系的全部，所以在添加班级的一方的时候，可以将多方添加进去
        Set<Student> stus =new HashSet<Student>();
        stus.add(stu1);
        stus.add(stu2);
        stus.add(stu3);
        cla.setStudent(stus);
        new MyClassDao().add(cla);
    }
    
    
    /***
     * 删除 一方 对象
     * 因为 一方对象 设置了双方关系维护规则为 ALL，所以会将多方的数据同时删除
*/
    public void deleteStudenAndClassByCla()
    {
        new MyClassDao().delete("0613");
    }
    
}

真个简单的Demo就完成了。

然后而外啰嗦几句，

C#是后起之秀，并且本身就是借鉴JAVA来进行研发的，后来C#中的许多思想也被JAVA使用，因此两门语言的相似度可以达到90%，语法这些几乎无差别，就是命名差别大了些。另外，两门语言的一些规范，其实也有潜规则。JAVA的多使用骆驼命名法，C#中多使用帕斯卡命名法。