Flex+J2EE实例（cairngorm+blazeDS+hibernate+spring） part3

 * 根据实体类与ID获得对象



 * @param clazz 实体类



 * @param id 主键ID



 */



public <X> X get(final Class<X> clazz,final Serializable id) {



   return (X) getSession().get(clazz, id);



}







/**



 * 根据id获得对象



 * @param id 主键ID



 */



public T get(Serializable id){



    return get(entityClass, id);



}







/**



 * 删除对象



 * @param entity 实体类



 */



public void delete(final Object entity) {



   getSession().delete(entity);



}







/**



 * 根据ID删除对象



 * @param id 主键ID



 */



public void delete(final Serializable id) {



   delete(get(id));



}







/**



 * 根据实体类与ID删除对象



 * @param clazz 实体类



 * @param id 主键ID



 */



public void delete(final Class clazz, final Serializable id){



   delete(get(clazz,id));



}







/**



 * 保存对象



 * @param entity 保存的实体对象



 */



public void save(final Object entity) {



   getSession().saveOrUpdate(entity);



}







/**



 * 获取所有数据



 * @param entityClass 参数T的反射类型



 */



public <X> List<X> getAll(final Class<X> entityClass) {



   return createCriteria(entityClass).list();



}







/**



 * 获取所有数据



 */



public List<T> getAll() {



   return query();



}











/**



 * 根据条件获取数据



 * @param criterions 数量可变的Criterion



 */



public List<T> query(final Criterion... criterions) {



   return createCriteria(criterions).list();



}







/**



 * HQL方式查询



 * @param hql 符合HQL语法的查询语句



 * @param values 数量可变的条件值,按顺序绑定



 */



public Query createQuery(final String hql,final Object... values){



    Query query = getSession().createQuery(hql);



    int j = values.length;



    for(int i = 0; i < j; i++)



        query.setParameter(i, values[i]);



    return query;



}







/**



 * SQL方式查询



 * @param sql 符合SQL语法的查询语句



 * @param values 数量可变的条件值,按顺序绑定



 */



public SQLQuery createSQLQuery(final String sql,final Object... values){



    SQLQuery query = getSession().createSQLQuery(sql);



    if (values != null) {



       for (int i = 0; i < values.length; i++) {



          query.setParameter(i, values[i]);



       }



   }



    return query;



}







/**



 * 根据类型创建查询对象



 * @param clazz 类型



 */



public Criteria createCriteria(finalClass clazz) {



   return getSession().createCriteria(clazz);



}







/**



 * 对象化查询



 * @param entityClass 参数T的反射类型



 * @param criterions 数量可变的Criterion



 */



public Criteria createCriteria(finalClass clazz,final Criterion... criterions){



    Criteria criteria = getSession().createCriteria(clazz);



    for (Criterion c : criterions) {



       criteria.add(c);



   }



    return criteria;



}







/**



 * 对象化查询



 * @param criterions 数量可变的Criterion



 */



public Criteria createCriteria(final Criterion... criterions){



return createCriteria(entityClass, criterions);



}

}

########################

ReflectUtils.java

package com.core.utils;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

/**

• 反射工具类

*/

public class ReflectUtils {

/**



 * 获得超类的参数类型，取第一个参数类型



 * @param <T> 类型参数



 * @param clazz 超类类型



 */



public static <T> Class<T> getClassGenricType(finalClass clazz) {



   return getClassGenricType(clazz, 0);



}







/**



 * 根据索引获得超类的参数类型



 * @param clazz 超类类型



 * @param index 索引



 */



public static Class getClassGenricType(finalClass clazz,final int index) {



   Type genType = clazz.getGenericSuperclass();



   if (!(genType instanceof ParameterizedType)) {



       return Object.class;



   }



   Type[] params = ((ParameterizedType)genType).getActualTypeArguments();



   if (index >= params.length || index < 0) {



       return Object.class;



   }



   if (!(params[index] instanceofClass)) {



       return Object.class;



   }



   return (Class) params[index];



}

}

#########################

Administrator.java

package com.pkms.entity;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import static javax.persistence.GenerationType.IDENTITY;

import javax.persistence.Id;

import javax.persistence.Table;

/**

• Administrator entity. @author MyEclipse Persistence Tools

*/

@Entity

@Table(name = “administrator”, catalog = “pkms”)

public class Administrator implements java.io.Serializable {

// Fields







private Integer id;



private String loginName;



private String password;







// Constructors







/** default constructor */



public Administrator() {



}







/** full constructor */



public Administrator(String loginName, String password) {



   this.loginName = loginName;



   this.password = password;



}







// Property accessors



@Id



@GeneratedValue(strategy = IDENTITY)



@Column(name = "id", unique = true, nullable =false)



public Integer getId() {



   return this.id;



}







public void setId(Integer id) {



   this.id = id;



}







@Column(name = "loginName", length = 11)



public String getLoginName() {



   return this.loginName;



}







public void setLoginName(String loginName) {



   this.loginName = loginName;



}







@Column(name = "password", length = 11)



public String getPassword() {



   return this.password;



}







public void setPassword(String password) {



   this.password = password;



}

}

###########

AdministratorDAO.java

package com.pkms.dao;

import java.util.List;

import org.hibernate.Query;

import org.hibernate.Session;

import org.hibernate.SessionFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.flex.remoting.RemotingDestination;

import org.springframework.stereotype.Repository;

import com.core.hibernate.HibernateDao;

import com.pkms.entity.Administrator;

@SuppressWarnings(“unchecked”)

@Repository(“administratorDAO”)

public class AdministratorDAO extends HibernateDao{