泛型--浅谈在实际中的应用一

package cn.itcast.service.base;

import java.io.Serializable;
import java.util.LinkedHashMap;

import cn.itcast.bean.QueryResult;

public interface DAO<T> {
/**
* 获取记录总数
* @param entityClass 实体类
* @return
*/
public long getCount();
/**
* 清除一级缓存的数据
*/
public void clear();
/**
* 保存实体
* @param entity 实体id
*/
public void save(T entity);
/**
* 更新实体
* @param entity 实体id
*/
public void update(T entity);
/**
* 删除实体
* @param entityClass 实体类
* @param entityids 实体id数组
*/
public void delete(Serializable ... entityids);
/**
* 获取实体
* @param <T>
* @param entityClass 实体类
* @param entityId 实体id
* @return
*/
public T find(Serializable entityId);
/**
* 获取分页数据
* @param <T>
* @param entityClass 实体类
* @param firstindex 开始索引
* @param maxresult 需要获取的记录数
* @return
*/
public QueryResult<T> getScrollData(int firstindex, int maxresult, String wherejpql, Object[] queryParams,LinkedHashMap<String, String> orderby);

public QueryResult<T> getScrollData(int firstindex, int maxresult, String wherejpql, Object[] queryParams);

public QueryResult<T> getScrollData(int firstindex, int maxresult, LinkedHashMap<String, String> orderby);

public QueryResult<T> getScrollData(int firstindex, int maxresult);

public QueryResult<T> getScrollData();
}

package cn.itcast.service.base;

import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.util.LinkedHashMap;

import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import cn.itcast.bean.QueryResult;
import cn.itcast.utils.GenericsUtils;

@SuppressWarnings("unchecked")
@Transactional
public abstract class DaoSupport<T> implements DAO<T>{
protected Class<T> entityClass = GenericsUtils.getSuperClassGenricType(this.getClass());
@PersistenceContext protected EntityManager em;

public void clear(){
em.clear();
}

public void delete(Serializable ... entityids) {
for(Object id : entityids){
em.remove(em.getReference(this.entityClass, id));
}
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public T find(Serializable entityId) {
if(entityId==null) throw new RuntimeException(this.entityClass.getName()+ ":传入的实体id不能为空");
return em.find(this.entityClass, entityId);
}

public void save(T entity) {
em.persist(entity);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public long getCount() {
return (Long)em.createQuery("select count("+ getCountField(this.entityClass) +") from "+ getEntityName(this.entityClass)+ " o").getSingleResult();
}

public void update(T entity) {
em.merge(entity);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public QueryResult<T> getScrollData(int firstindex, int maxresult, LinkedHashMap<String, String> orderby) {
return getScrollData(firstindex,maxresult,null,null,orderby);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public QueryResult<T> getScrollData(int firstindex, int maxresult, String wherejpql, Object[] queryParams) {
return getScrollData(firstindex,maxresult,wherejpql,queryParams,null);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public QueryResult<T> getScrollData(int firstindex, int maxresult) {
return getScrollData(firstindex,maxresult,null,null,null);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public QueryResult<T> getScrollData() {
return getScrollData(-1, -1);
}

@Transactional(readOnly=true,propagation=Propagation.NOT_SUPPORTED)
public QueryResult<T> getScrollData(int firstindex, int maxresult
, String wherejpql, Object[] queryParams,LinkedHashMap<String, String> orderby) {
QueryResult qr = new QueryResult<T>();
String entityname = getEntityName(this.entityClass);
Query query = em.createQuery("select o from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where "+ wherejpql)+ buildOrderby(orderby));
setQueryParams(query, queryParams);
if(firstindex!=-1 && maxresult!=-1) query.setFirstResult(firstindex).setMaxResults(maxresult);
qr.setResultlist(query.getResultList());
query = em.createQuery("select count("+ getCountField(this.entityClass)+ ") from "+ entityname+ " o "+(wherejpql==null || "".equals(wherejpql.trim())? "": "where "+ wherejpql));
setQueryParams(query, queryParams);
qr.setTotalrecord((Long)query.getSingleResult());
return qr;
}

protected static void setQueryParams(Query query, Object[] queryParams){
if(queryParams!=null && queryParams.length>0){
for(int i=0; i<queryParams.length; i++){
query.setParameter(i+1, queryParams[i]);
}
}
}
/**
* 组装order by语句
* @param orderby
* @return
*/
protected static String buildOrderby(LinkedHashMap<String, String> orderby){
StringBuffer orderbyql = new StringBuffer("");
if(orderby!=null && orderby.size()>0){
orderbyql.append(" order by ");
for(String key : orderby.keySet()){
orderbyql.append("o.").append(key).append(" ").append(orderby.get(key)).append(",");
}
orderbyql.deleteCharAt(orderbyql.length()-1);
}
return orderbyql.toString();
}
/**
* 获取实体的名称
* @param <E>
* @param clazz 实体类
* @return
*/
protected static <E> String getEntityName(Class<E> clazz){
String entityname = clazz.getSimpleName();
Entity entity = clazz.getAnnotation(Entity.class);
if(entity.name()!=null && !"".equals(entity.name())){
entityname = entity.name();
}
return entityname;
}
/**
* 获取统计属性,该方法是为了解决hibernate解析联合主键select count(o) from Xxx o语句BUG而增加,hibernate对此jpql解析后的sql为select count(field1,field2,...),显示使用count()统计多个字段是错误的
* @param <E>
* @param clazz
* @return
*/
protected static <E> String getCountField(Class<E> clazz){
String out = "o";
try {
PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(clazz).getPropertyDescriptors();
for(PropertyDescriptor propertydesc : propertyDescriptors){
Method method = propertydesc.getReadMethod();
if(method!=null && method.isAnnotationPresent(EmbeddedId.class)){
PropertyDescriptor[] ps = Introspector.getBeanInfo(propertydesc.getPropertyType()).getPropertyDescriptors();
out = "o."+ propertydesc.getName()+ "." + (!ps[1].getName().equals("class")? ps[1].getName(): ps[0].getName());
break;
}
}
} catch (Exception e) {
e.printStackTrace();
}
return out;
}
}

package cn.itcast.service.book;

import cn.itcast.bean.BuyCart;
import cn.itcast.bean.book.DeliverWay;
import cn.itcast.bean.book.Order;
import cn.itcast.bean.book.PaymentWay;
import cn.itcast.service.base.DAO;

public interface OrderService extends DAO<Order> {
/**
* 解锁订单
* @param orderids 订单号
*/
public void unlock(String... orderids);
/**
* 加锁订单
* @param orderid 订单号
* @param username 加锁用户
* @return
*/
public Order addLock(String orderid, String username);
/**
* 把订单转为已收货状态
* @param orderid 订单号
*/
public void turnReceived(String orderid);
/**
* 把订单转为已发货状态
* @param orderid 订单号
*/
public void turnDelivered(String orderid);
/**
* 把订单转为等待发货状态
* @param orderid 订单号
*/
public void turnWaitdeliver(String orderid);

/**
* 财务确认已付款
* @param orderid 订单号
*/
public void confirmPayment(String orderid);
/**
* 审核通过订单
* @param orderid 订单号
*/
public void confirmOrder(String orderid);
/**
* 取消订单
* @param orderid 订单号
*/
public void cannelOrder(String orderid);
/**
* 生成订单
* @param buyCart 购物车
* @param username 用户名
* @return
*/
public Order createOrder(BuyCart buyCart, String username);
/**
* 更新支付方式
* @param orderid 订单号
* @param paymentWay 支付方式
*/
public void updatePaymentWay(String orderid, PaymentWay paymentWay);
/**
* 更新配送方式
* @param orderid 订单号
* @param deliverWay 配送方式
*/
public void updateDeliverWay(String orderid, DeliverWay deliverWay);
/**
* 更新配送费
* @param orderid 订单号
* @param deliverFee 配送费
*/
public void updateDeliverFee(String orderid, float deliverFee);
}

package cn.itcast.service.book.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import javax.annotation.Resource;
import javax.persistence.Query;

import org.springframework.stereotype.Service;

import cn.itcast.bean.BuyCart;
import cn.itcast.bean.BuyItem;
import cn.itcast.bean.book.DeliverWay;
import cn.itcast.bean.book.Order;
import cn.itcast.bean.book.OrderItem;
import cn.itcast.bean.book.OrderState;
import cn.itcast.bean.book.PaymentWay;
import cn.itcast.bean.product.ProductStyle;
import cn.itcast.bean.user.Buyer;
import cn.itcast.bean.user.ContactInfo;
import cn.itcast.service.base.DaoSupport;
import cn.itcast.service.book.GeneratedOrderidService;
import cn.itcast.service.book.OrderService;

@Service
public class OrderServiceBean extends DaoSupport<Order> implements OrderService {
@Resource GeneratedOrderidService generatedOrderidService;
/*
@PostConstruct public void init(){
generatedOrderidService.init();
}
*/
public void unlock(String... orderids){
if(orderids!=null && orderids.length>0){
StringBuilder sb = new StringBuilder();
for(int i=0 ; i < orderids.length ; i++){
sb.append('?').append(i+2).append(',');
}
sb.deleteCharAt(sb.length()-1);
Query query = em.createQuery("update Order o set o.lockuser=?1 where o.orderid in("+ sb +")");
query.setParameter(1, null);
for(int i=0 ; i < orderids.length ; i++){
query.setParameter(i+2, orderids[i]);
}
query.executeUpdate();
}

}

public Order addLock(String orderid, String username){
Query query = em.createQuery("update Order o set o.lockuser=?1 where o.orderid=?2 and o.lockuser is null and o.state=?3");
query.setParameter(1, username);
query.setParameter(2, orderid);
query.setParameter(3, OrderState.WAITCONFIRM);
query.executeUpdate();
em.flush();
return find(orderid);
}

public void turnReceived(String orderid){
Order order = this.find(orderid);
if(OrderState.DELIVERED.equals(order.getState())){
order.setState(OrderState.RECEIVED);
}
}

public void turnDelivered(String orderid){
Order order = this.find(orderid);
if(OrderState.WAITDELIVER.equals(order.getState())){
order.setState(OrderState.DELIVERED);
}
}

public void turnWaitdeliver(String orderid){
Order order = this.find(orderid);
if(OrderState.ADMEASUREPRODUCT.equals(order.getState())){
order.setState(OrderState.WAITDELIVER);
}
}

public void confirmPayment(String orderid){
Order order = this.find(orderid);
order.setPaymentstate(true);
if(OrderState.WAITPAYMENT.equals(order.getState())){
order.setState(OrderState.ADMEASUREPRODUCT);
}else if(OrderState.DELIVERED.equals(order.getState()) && PaymentWay.COD.equals(order.getPaymentWay())){
order.setState(OrderState.RECEIVED);
}
}

public void confirmOrder(String orderid){
Order order = this.find(orderid);
if(OrderState.WAITCONFIRM.equals(order.getState())){
if(!PaymentWay.COD.equals(order.getPaymentWay()) && !order.getPaymentstate()){
order.setState(OrderState.WAITPAYMENT);
}else{
order.setState(OrderState.ADMEASUREPRODUCT);
}
}
order.setLockuser(null);
}
public void cannelOrder(String orderid){
Order order = this.find(orderid);
if(!OrderState.RECEIVED.equals(order.getState())){
order.setState(OrderState.CANCEL);
}
order.setLockuser(null);
}

public void updateDeliverFee(String orderid, float deliverFee){
Order order = this.find(orderid);
order.setDeliverFee(deliverFee);
order.setTotalPrice(order.getProductTotalPrice()+ order.getDeliverFee());
order.setPayablefee(order.getTotalPrice());
}

public void updatePaymentWay(String orderid, PaymentWay paymentWay){
em.createQuery("update Order o set o.paymentWay=?1 where o.orderid=?2")
.setParameter(1, paymentWay).setParameter(2, orderid).executeUpdate();
}

public void updateDeliverWay(String orderid, DeliverWay deliverWay){
/*
* 下面语句在hibernate中执行出错,这是hibernate的bug导致的,如果用在TopLink上,下面语句能成功执行
* em.createQuery("update OrderDeliverInfo o set o.deliverWay=?1 where o.order.orderid=?2")
.setParameter(1, deliverWay).setParameter(2, orderid).executeUpdate();*/
Order order = this.find(orderid);
order.getOrderDeliverInfo().setDeliverWay(deliverWay);
}

public Order createOrder(BuyCart buyCart, String username){
Order order = new Order();
Buyer buyer = em.find(Buyer.class, username);
order.setBuyer(buyer);
order.setDeliverFee(buyCart.getDeliveFee());
order.setNote(buyCart.getNote());
order.setOrderContactInfo(buyCart.getContactInfo());
order.setOrderDeliverInfo(buyCart.getDeliverInfo());
order.setState(OrderState.WAITCONFIRM);
order.setPaymentWay(buyCart.getPaymentWay());
order.setProductTotalPrice(buyCart.getTotalSellPrice());
order.setTotalPrice(buyCart.getOrderTotalPrice());
order.setPayablefee(buyCart.getOrderTotalPrice());
for(BuyItem item : buyCart.getItems()){
ProductStyle style = item.getProduct().getStyles().iterator().next();
OrderItem oitem = new OrderItem(item.getProduct().getName(), item.getProduct().getId(),
item.getProduct().getSellprice(), item.getAmount(), style.getName(), style.getId());
order.addOrderItem(oitem);
}
if(buyer.getContactInfo()==null){
buyer.setContactInfo(new ContactInfo());
buyer.getContactInfo().setAddress(order.getOrderContactInfo().getAddress());
buyer.getContactInfo().setPostalcode(order.getOrderContactInfo().getPostalcode());
buyer.getContactInfo().setPhone(order.getOrderContactInfo().getTel());
buyer.getContactInfo().setMobile(order.getOrderContactInfo().getMobile());
if(buyer.getRealname()==null) buyer.setRealname(order.getOrderContactInfo().getBuyerName());
if(buyer.getGender()==null) buyer.setGender(order.getOrderContactInfo().getGender());
}
order.setOrderid(buildOrderid2(order.getCreateDate()));
this.save(order);
return order;
}

/**
* 生成订单号,订单号的组成:两位年份两位月份两位日期+(流水号,不够8位前面补零),如:09120200000001
* @return
*/
private String buildOrderid2(Date date) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
StringBuilder sb = new StringBuilder(dateFormat.format(date));
sb.append(fillZero(8, String.valueOf(generatedOrderidService.buildOrderid())));
return sb.toString();
}
/**
* 生成订单号,订单号的组成:两位年份两位月份两位日期+(当天订单总数+1),如果订单总数的长度不够8位,前面补零,如:09120200000001
* @return
*/
private String buildOrderid(Date date) {
SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
StringBuilder sb = new StringBuilder(dateFormat.format(date));
dateFormat = new SimpleDateFormat("yyyy-MM-dd");
try {
Date now = dateFormat.parse(dateFormat.format(date));// 2009-12-02 00:00
Query query = em.createQuery("select count(o) from Order o where o.createDate>=?1");
query.setParameter(1, now);
long count = (Long)query.getSingleResult();
sb.append(fillZero(8, String.valueOf(count+1)));
} catch (ParseException e) {
throw new RuntimeException("生成订单号失败");
}
return sb.toString();
}
/**
* 补零
* @param length 补零后的长度
* @param source 需要补零的长符串
* @return
*/
private String fillZero(int length, String source) {//7
StringBuilder result = new StringBuilder(source);
for(int i=result.length(); i<length ; i++){
result.insert(0, '0');
}
return result.toString();
}
}

package cn.itcast.utils;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;
/**
* 泛型工具类
* @author lihuoming
*
*/
public class GenericsUtils {
/**
* 通过反射,获得指定类的父类的泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>
*
* @param clazz clazz 需要反射的类,该类必须继承范型父类
* @param index 泛型参数所在索引,从0开始.
* @return 范型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(Class clazz, int index) {
Type genType = clazz.getGenericSuperclass();//得到泛型父类
//如果没有实现ParameterizedType接口，即不支持泛型，直接返回Object.class
if (!(genType instanceof ParameterizedType)) {
return Object.class;
}
//返回表示此类型实际类型参数的Type对象的数组,数组里放的都是对应类型的Class, 如BuyerServiceBean extends DaoSupport<Buyer,Contact>就返回Buyer和Contact类型
Type[] params = ((ParameterizedType) genType).getActualTypeArguments();
if (index >= params.length || index < 0) {
throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
}
if (!(params[index] instanceof Class)) {
return Object.class;
}
return (Class) params[index];
}
/**
* 通过反射,获得指定类的父类的第一个泛型参数的实际类型. 如BuyerServiceBean extends DaoSupport<Buyer>
*
* @param clazz clazz 需要反射的类,该类必须继承泛型父类
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(Class clazz) {
return getSuperClassGenricType(clazz,0);
}
/**
* 通过反射,获得方法返回值泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
*
* @param Method method 方法
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getMethodGenericReturnType(Method method, int index) {
Type returnType = method.getGenericReturnType();
if(returnType instanceof ParameterizedType){
ParameterizedType type = (ParameterizedType) returnType;
Type[] typeArguments = type.getActualTypeArguments();
if (index >= typeArguments.length || index < 0) {
throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
}
return (Class)typeArguments[index];
}
return Object.class;
}
/**
* 通过反射,获得方法返回值第一个泛型参数的实际类型. 如: public Map<String, Buyer> getNames(){}
*
* @param Method method 方法
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getMethodGenericReturnType(Method method) {
return getMethodGenericReturnType(method, 0);
}

/**
* 通过反射,获得方法输入参数第index个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
*
* @param Method method 方法
* @param int index 第几个输入参数
* @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
*/
@SuppressWarnings("unchecked")
public static List<Class> getMethodGenericParameterTypes(Method method, int index) {
List<Class> results = new ArrayList<Class>();
Type[] genericParameterTypes = method.getGenericParameterTypes();
if (index >= genericParameterTypes.length ||index < 0) {
throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
}
Type genericParameterType = genericParameterTypes[index];
if(genericParameterType instanceof ParameterizedType){
ParameterizedType aType = (ParameterizedType) genericParameterType;
Type[] parameterArgTypes = aType.getActualTypeArguments();
for(Type parameterArgType : parameterArgTypes){
Class parameterArgClass = (Class) parameterArgType;
results.add(parameterArgClass);
}
return results;
}
return results;
}
/**
* 通过反射,获得方法输入参数第一个输入参数的所有泛型参数的实际类型. 如: public void add(Map<String, Buyer> maps, List<String> names){}
*
* @param Method method 方法
* @return 输入参数的泛型参数的实际类型集合, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回空集合
*/
@SuppressWarnings("unchecked")
public static List<Class> getMethodGenericParameterTypes(Method method) {
return getMethodGenericParameterTypes(method, 0);
}
/**
* 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
*
* @param Field field 字段
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getFieldGenericType(Field field, int index) {
Type genericFieldType = field.getGenericType();

if(genericFieldType instanceof ParameterizedType){
ParameterizedType aType = (ParameterizedType) genericFieldType;
Type[] fieldArgTypes = aType.getActualTypeArguments();
if (index >= fieldArgTypes.length || index < 0) {
throw new RuntimeException("你输入的索引"+ (index<0 ? "不能小于0" : "超出了参数的总数"));
}
return (Class)fieldArgTypes[index];
}
return Object.class;
}
/**
* 通过反射,获得Field泛型参数的实际类型. 如: public Map<String, Buyer> names;
*
* @param Field field 字段
* @param int index 泛型参数所在索引,从0开始.
* @return 泛型参数的实际类型, 如果没有实现ParameterizedType接口，即不支持泛型，所以直接返回<code>Object.class</code>
*/
@SuppressWarnings("unchecked")
public static Class getFieldGenericType(Field field) {
return getFieldGenericType(field, 0);
}
}