如果没接触过动态语言,以编译型语言的思维方式去理解JavaScript将会有种神奇而怪异的感觉,因为意识上往往不可能的事偏偏就发生了,甚至觉得不可理喻.如果在学JavaScript这自由而变幻无穷的语言过程中遇到这种感觉,那么就从现在形始,请放下的您的”偏见”,因为这对您来说绝对是一片新大陆,让JavaScrip慢慢融化以前一套凝固的编程意识,注入新的生机!
好,言归正传,先理解JavaScrtipt动态变换运行时上下文特性,这种特性主要就体现在apply, call两个方法的运用上.
区分apply,call就一句话,
网上有很多的通用泛型DAO,我收集了很多,吸取中间的精华,整理出来了这个Hibernae泛型DAO
，直接上代码了
@SuppressWarnings("unchecked")
public abstract class SpringDaoSupportImp<T, ID extends Serializable> extends HibernateDaoSupport implements
IHibernateDaoSupport<T, ID> {
protected Logger log = LoggerFactory.getLogger(super.getClass());
protected Class<T> entityClass;
private boolean cacheable = false;
public SpringDaoSupportImp() {
this.entityClass = ReflectionUtils.getSuperClassGenricType(super.getClass());
}
public abstract void setSuperSessionFactory(SessionFactory sessionFactory);
public SpringDaoSupportImp(SessionFactory sessionFactory, Class<T> entityClass) {
super.setSessionFactory(sessionFactory);// = sessionFactory;
this.entityClass = entityClass;
}
/**
* 获得总记录数.
*
* @param criteria 条件
* @return 总数
*/
public Integer getCount(Criteria criteria) {
Object result = criteria.setProjection(Projections.rowCount()).uniqueResult();
return ((Number) result).intValue();
}
/**
* 取得对象的主键名,辅助函数.
*
* @param entityClass 实体类型
* @return 主键名称
*/
public String getIdName(Class entityClass) {
Assert.notNull(entityClass);
log.debug("取得对象的主键名,辅助函数:" + entityClass);
ClassMetadata meta = getSessionFactory().getClassMetadata(entityClass);
Assert.notNull(meta, "Class " + entityClass + " not define in hibernate session factory.");
String idName = meta.getIdentifierPropertyName();
Assert.hasText(idName, entityClass.getSimpleName() + " has no identifier property define.");
return idName;
}
public String getIdName() {
ClassMetadata meta = getSessionFactory().getClassMetadata(this.entityClass);
return meta.getIdentifierPropertyName();
}
/**
* 取得对象的主键值，辅助函数.
*
* @param entityClass 实体类型
* @param entity 实例
* @return 主键
* @throws NoSuchMethodException 找不到方法
* @throws IllegalAccessException 没有访问权限
* @throws InvocationTargetException 反射异常
*/
public Serializable getId(Class entityClass, Object entity) throws NoSuchMethodException, IllegalAccessException,
InvocationTargetException {
Assert.notNull(entity);
Assert.notNull(entityClass);
return (Serializable) PropertyUtils.getProperty(entity, getIdName());
}
public void save(T entity) {
log.info("saving entity...........");
Assert.notNull(entity);
super.getHibernateTemplate().save(entity);
}
public void saveOrUpdate(T entity) {
log.info("saveOrUpdate entity...........");
Assert.notNull(entity);
super.getHibernateTemplate().saveOrUpdate(entity);
}
public void delete(T entity) {
Assert.notNull(entity, "删除的entity不能为null");
super.getHibernateTemplate().delete(entity);
}
public void delete(ID... ids) {
if (ArrayUtils.getLength(ids) > 1) {
for (int i = 0; i < ids.length; i++)
removeById(ids[i]);
} else
this.delete(get(ArrayUtils.first(ids)));
}
public void deleteByIdWithQuery(ID... ids) {
for (int i = 0; i < ArrayUtils.getLength(ids); i++) {
removeById(ids[i]);
}
}
/**
* 根据name,value进行模糊查询.
*
* @param <T> 实体类型
* @param entityClass 实体类型
* @param name 字段名
* @param value 用来做模糊查询的字段值
* @return 查询结果
*/
public List<T> findByPropertyLike(Class<T> entityClass, String propertyName, Object value) {
return this.createCriteria(entityClass, Restrictions.like(propertyName, value)).list();
}
public List<T> findByPropertyLikeANYWHERE(String propertyName, String value) {
return this.createCriteria(entityClass, Restrictions.like(propertyName, value, MatchMode.ANYWHERE)).list();
}
/**
* 根据entityClass，生成带排序的Criteria.
*
* @param <T> 实体类型
* @param entityClass 类型
* @param orderBy 排序字段名
* @param isAsc 是否正序
* @param criterions 条件
* @return Criteria
*/
public Criteria createCriteria(Class<T> entityClass, String orderBy, boolean isAsc, Criterion... criterions) {
if ((orderBy == null) || orderBy.trim().equals("")) {
return createCriteria(entityClass, criterions);
} else {
Criteria criteria = createCriteria(entityClass, criterions);
if (isAsc) {
criteria.addOrder(Order.asc(orderBy));
} else {
criteria.addOrder(Order.desc(orderBy));
}
return criteria;
}
}
/**
* 根据entityClass生成对应类型的Criteria.
*
* @param entityClass 实体类型
* @param criterions 条件
* @return Criteria
*/
public Criteria createCriteria(Class entityClass, Criterion... criterions) {
Criteria criteria = getSession().createCriteria(entityClass);
for (Criterion c : criterions) {
criteria.add(c);
}
return criteria;
}
public T get(ID id) {
log.info("" + this.entityClass);
return get(this.entityClass, id);
}
public T get(Class<T> entityClass, ID id) {
return (T) super.getHibernateTemplate().get(entityClass, id);
}
public T load(ID id) {
return (T) super.getHibernateTemplate().load(entityClass, id);
}
public List<T> getAllWithCache() {
return setCacheQueries(true).loadAll(entityClass);
}
public List<T> getAll() {
return getHibernateTemplate().loadAll(entityClass);
}
public T findUniqueByNamedQuery(String queryName, Object... values) {
return (T) getNamedQuery(queryName, values).uniqueResult();
}
public List<T> getAll(String orderBy, boolean isAsc) {
Criteria c = createCriteria(new Criterion[0]);
if (isAsc)
c.addOrder(Order.asc(orderBy));
else
c.addOrder(Order.desc(orderBy));
return c.list();
}
protected HibernateTemplate setCacheQueries(boolean cacheQueries) {
HibernateTemplate template = super.getHibernateTemplate();
template.setCacheQueries(cacheQueries);
return template;
}
public List<T> findByHQL(String hql) {
return super.getHibernateTemplate().find(hql);
}
public List<T> find(Integer maxSize, String queryString, Object... values) {
Query query = createQuery(queryString, values);
query.setMaxResults(maxSize);
return query.list();
}
public List<T> findByHql(String hql, Object... values) {
return super.getHibernateTemplate().find(hql, values);
}
public List<T> findByHQLWithCache(String hql, Object... values) {
HibernateTemplate template = super.getHibernateTemplate();
template.setCacheQueries(true);
return template.find(hql, values);
}
public Object findUnique(String hql, Map<String, Object> values) {
return createQuery(hql, values).uniqueResult();
}
public Object findUniqueWithCache(String hql, Map<String, Object> values) {
return createQuery(hql, values).setCacheable(true).uniqueResult();
}
public Object findUnique(String hql, Object... values) {
return createQuery(hql, values).uniqueResult();
}
public Object findUniqueWithCache(String hql, Object... values) {
return createQuery(hql, values).setCacheable(true).uniqueResult();
}
public T findUniqueByHql(String queryString, Object... values) {
return (T) createQuery(queryString, values).uniqueResult();
}
public Object findUniqueBySql(String sql, Object... values) {
return createSQLQuery(sql, values).uniqueResult();
}
public Object findUniqueBySql(String sql, Map<String, Object> values) {
return createSQLQuery(sql, values).uniqueResult();
}
public void update(T entity) {
super.getHibernateTemplate().update(entity);
}
public void removeBatch(final Class<T> clazz, final ID... ids) {
Assert.notNull(clazz, "要移除的对象类型不能为空!");
getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
for (int i = 0; i < ids.length; i++) {
Object obj = session.load(clazz, ids[i]);
if (obj != null) {
session.delete(obj);
} else {
log.warn("无法删除主键为:" + ids[i] + "的" + clazz.getName());
}
}
return null;
}
});
}
public void refresh(Object object) {
getHibernateTemplate().refresh(object);
}
/**
* 得到查到的最前一个对象.
*
* @param clazz
* 类名.
* @param criterions
* 查询条件.
* @return 查询得到的结果.
*/
public T getFirst(Criterion... criterions) {
List<T> lt = findByCriteria(criterions);
if (lt != null && !lt.isEmpty()) {
return lt.get(0);
}
return null;
}
public List<T> findByCriteria(final Criterion[] criterions, final Order... orders) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException, SQLException {
Criteria criteria = createCriteria(criterions);
if (criterions != null && criterions.length > 0) {
for (int i = 0; i < criterions.length; i++) {
criteria.add(criterions[i]);
}
}
if (orders != null && orders.length > 0) {
for (int i = 0; i < orders.length; i++) {
criteria.addOrder(orders[i]);
}
}
return criteria.list();
}
});
}
public void updateAll(List<T> entities) {
super.getHibernateTemplate().saveOrUpdateAll(entities);
}
public List<T> findByCriteria(Collection<Criterion> criterion) {
DetachedCriteria detachedCrit = DetachedCriteria.forClass(entityClass);
for (Criterion c : criterion) {
detachedCrit.add(c);
}
return getHibernateTemplate().findByCriteria(detachedCrit);
}
public void deleteAll(Collection<T> entities) {
super.getHibernateTemplate().deleteAll(entities);
}
// 加锁并删除指定的实体
public void deleteWithLock(T entity, LockMode lock) {
getHibernateTemplate().delete(entity, lock);
this.flush(); // 立即刷新，否则锁不会生效。
}
public void lock(T entity, LockMode lockMode) {
super.getHibernateTemplate().lock(entity, lockMode);
}
// 使用带参数的HSQL语句增加、更新、删除实体
public int bulkUpdate(String queryString, Object... values) {
return getHibernateTemplate().bulkUpdate(queryString, values);
}
public Object getStatValue(DetachedCriteria criteria, String propertyName, String StatName) {
if (StatName.toLowerCase().equals("max"))
criteria.setProjection(Projections.max(propertyName));
else if (StatName.toLowerCase().equals("min"))
criteria.setProjection(Projections.min(propertyName));
else if (StatName.toLowerCase().equals("avg"))
criteria.setProjection(Projections.avg(propertyName));
else if (StatName.toLowerCase().equals("sum"))
criteria.setProjection(Projections.sum(propertyName));
else
return null;
List list = this.findByCriteria(criteria, 0, 1);
return list.get(0);
}
public List<T> findByCriteria(DetachedCriteria criteria, int firstResult, int maxResults) {
return getHibernateTemplate().findByCriteria(criteria, firstResult, maxResults);
}
public List<T> findByCriteria(DetachedCriteria criteria) {
return findByCriteria(criteria, -1, -1);
}
public List<T> findByCriteria(Criterion... criterions) {
return createCriteria(criterions).list();
}
public List<T> findByCriteriaWithCache(Criterion... criterions) {
return createCriteriaWithCache(criterions).list();
}
public T getUniqueResultByCriteria(Criterion... criterions) {
return (T) createCriteria(criterions).uniqueResult();
}
public T getUniqueResultByCriteriaWithCache(Criterion... criterions) {
return (T) createCriteria(criterions).setCacheable(true).uniqueResult();
}
public Integer getRowCount(DetachedCriteria criteria) {
return (Integer) super.getHibernateTemplate().findByCriteria(criteria).get(0);
}
public Integer count() {//上面的用法
DetachedCriteria criteria = createDetachedCriteria();
criteria.setProjection(Projections.rowCount());
return getRowCount(criteria);
}
public void clear() {
getSession().clear();
}
public boolean contains(T t) throws DataAccessException {
return getHibernateTemplate().contains(t);
}
public Iterator<T> iterate(String hql, Object... values) {
return getHibernateTemplate().iterate(hql, values);
}
public List<T> findByNamedQuery(String queryName, String[] paramNames, Object[] values) {
return super.getHibernateTemplate().findByNamedQueryAndNamedParam(queryName, paramNames, values);
}
public List<T> findByNamedQuery(String queryName, Object... values) {
return super.getHibernateTemplate().findByNamedQuery(queryName, values);
}
public List<T> findByNamedQueryWithCache(String queryName, Object... values) {
HibernateTemplate template = getHibernateTemplate();
template.setCacheQueries(true);
return template.findByNamedQuery(queryName, values);
}
public List<T> findByNamedQuery(String queryName) {
return super.getHibernateTemplate().findByNamedQuery(queryName);
}
// 创建与会话无关的检索标准
public DetachedCriteria createDetachedCriteria() {
return DetachedCriteria.forClass(this.entityClass);
}
// 创建与会话绑定的检索标准
public Criteria createCriteria() {
return this.createDetachedCriteria().getExecutableCriteria(this.getSession());
}
public void flush() {
getHibernateTemplate().flush();
}
public Query createQuery(String queryString, Object... values) {
int i;
Assert.hasText(queryString);
Query query = getCurrentSession().createQuery(queryString);
if (values != null)
for (i = 0; i < values.length; ++i)
query.setParameter(i, values[i]);
return query;
}
protected Query createQuery(String queryString, Map<String, Object> values) {
Assert.hasText(queryString);
Query query = getCurrentSession().createQuery(queryString);
if (values != null)
for (Map.Entry<String, Object> entry : values.entrySet())
query.setParameter(entry.getKey(), entry.getValue());
return query;
}
protected Query getNamedQuery(String queryName, Object... values) {
int i;
Assert.hasText(queryName);
Query query = getCurrentSession().getNamedQuery(queryName);
if (values != null)
for (i = 0; i < values.length; ++i)
query.setParameter(i, values[i]);
return query;
}
protected Query createSQLQuery(String queryString, Object... values) {
int i;
Assert.hasText(queryString);
Query query = getCurrentSession().createSQLQuery(queryString);
if (values != null)
for (i = 0; i < values.length; ++i)
query.setParameter(i, values[i]);
return query;
}
protected Query createSQLQuery(String queryString, Map<String, Object> values) {
Assert.hasText(queryString);
Query query = getCurrentSession().createSQLQuery(queryString);
if (values != null)
for (Map.Entry<String, Object> entry : values.entrySet())
query.setParameter(entry.getKey(), entry.getValue());
return query;
}
public List<T> findByProperty(String propertyName, Object value, boolean cacheable) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
if (cacheable)
return findByCriteriaWithCache(criterion);
else
return findByCriteria(criterion);
}
public List<T> findByProperty(String propertyName, Object value) {
return findByProperty(propertyName, value, false);
}
public List<T> findAll(int firstResult, int size) {
DetachedCriteria date = createDetachedCriteria();
return getHibernateTemplate().findByCriteria(date, firstResult, size);
}
public List<T> findAll() {
return findAll(-1, -1);
}
public List<T> findAllWithCache() {
String queryString = "from " + getTableName();
Query query = createQuery(queryString);
query.setCacheable(true);
return query.list();
}
public List<T> findByProperty(Map<String, Object> values) {
Criterion criterion = Restrictions.allEq(values);
Criteria criteria = createCriteria();
criteria.add(criterion);
return criteria.list();
}
public List<T> findByProperty(String[] propertyNames, Object[] values) {
String queryString = "from " + getTableName() + " as model where";
for (String propertyName : propertyNames) {
queryString += " model." + propertyName + "=? and";
}
queryString = StringUtils.removeEnd(queryString, "and");
return getHibernateTemplate().find(queryString, values);
}
public List<T> findByProperty(String propertyName, Object value, int firstResult, int size) {
DetachedCriteria date = DetachedCriteria.forClass(typeClass());
date.add(Restrictions.eq(propertyName, value));
return getHibernateTemplate().findByCriteria(date, firstResult, size);
}
public List<T> findByPropertyLike(String propertyName, Object value, int firstResult, int size) {
DetachedCriteria date = DetachedCriteria.forClass(typeClass());
date.add(Restrictions.like(propertyName, String.valueOf(value), MatchMode.ANYWHERE));
return getHibernateTemplate().findByCriteria(date, firstResult, size);
}
public List findByPropertyLike(String propertyName, Object value) {
String queryString = " from " + getTableName() + " as model where LOWER(model." + propertyName + ") like ?";
String lowerValue = "%" + String.valueOf(value).toLowerCase() + "%";
return getHibernateTemplate().find(queryString, lowerValue);
}
public T findUniqueByProperty(String propertyName, Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(new Criterion[] { criterion }).uniqueResult();
}
public T findUniqueByPropertyWithCache(String propertyName, Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteriaWithCache(new Criterion[] { criterion }).uniqueResult();
}
public List<T> findByExample(T entity) {
return getHibernateTemplate().findByExample(entity);
}
public List<T> findByIds(List<ID> ids) {
return findByCriteria(Restrictions.in(getIdName(entityClass), ids));
}
public void initEntity(T entity) {
Hibernate.initialize(entity);
}
public void initEntity(List<T> entityList) {
for (Iterator i$ = entityList.iterator(); i$.hasNext();) {
Object entity = i$.next();
Hibernate.initialize(entity);
}
}
public Query distinct(Query query) {
query.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return query;
}
public Criteria distinct(Criteria criteria) {
criteria.setResultTransformer(CriteriaSpecification.DISTINCT_ROOT_ENTITY);
return criteria;
}
protected Criteria createCriteria(Criterion... criterions) {
Criteria criteria = getCurrentSession().createCriteria(this.entityClass);
Criterion[] arr$ = criterions;
int len$ = arr$.length;
for (int i$ = 0; i$ < len$; ++i$) {
Criterion c = arr$[i$];
criteria.add(c);
}
return criteria;
}
protected Criteria createCriteriaWithCache(Criterion... criterions) {
return createCriteria(criterions).setCacheable(true);
}
public T findByUnique(String propertyName, Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(new Criterion[] { criterion }).uniqueResult();
}
public T findByUnique(String propertyName, boolean cacheable, Object value) {
Assert.hasText(propertyName, "propertyName不能为空");
Criterion criterion = Restrictions.eq(propertyName, value);
return (T) createCriteria(new Criterion[] { criterion }).setCacheable(cacheable).uniqueResult();
}
public List<T> find(String queryString, Object... values) {
return findByHql(queryString, values);
}
public boolean isPropertyUnique(String propertyName, Object newValue, Object orgValue) {
if ((newValue == null) || (newValue.equals(orgValue)))
return true;
Object object = findByUnique(propertyName, newValue);
return (object == null);
}
protected Session getCurrentSession() {
return super.getHibernateTemplate().getSessionFactory().getCurrentSession();
}
protected int countCriteriaResult(Criteria c) {
CriteriaImpl impl = (CriteriaImpl) c;
Projection projection = impl.getProjection();
ResultTransformer transformer = impl.getResultTransformer();
List orderEntries = null;
try {
orderEntries = (List) ReflectionUtils.getFieldValue(impl, "orderEntries");
ReflectionUtils.setFieldValue(impl, "orderEntries", new ArrayList());
} catch (Exception e) {
this.log.error("不可能抛出的异常:{}", e.getMessage());
}
int totalCount = ((Integer) c.setProjection(Projections.rowCount()).uniqueResult()).intValue();
c.setProjection(projection);
if (projection == null)
c.setResultTransformer(CriteriaSpecification.ROOT_ENTITY);
if (transformer != null)
c.setResultTransformer(transformer);
try {
ReflectionUtils.setFieldValue(impl, "orderEntries", orderEntries);
} catch (Exception e) {
this.log.error("不可能抛出的异常:{}", e.getMessage());
}
return totalCount;
}
public Map<String, Object> findBySqlUniqueToMap(String queryString, Map<String, Object> values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
return (Map<String, Object>) query.uniqueResult();
}
public List<Map<String, Object>> findBySqlToMapList(String queryString, Map<String, Object> values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
return query.list();
}
public List<Map<String, Object>> findBySqlToMapList(String queryString, Object... values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
return query.list();
}
public List<Object> findBySqlToList(String queryString, Map<String, Object> values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.TO_LIST);
return query.list();
}
public List<Object> findBySqlToList(String queryString, Object... values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.TO_LIST);
return query.list();
}
public List<Map<String, Object>> findBySqlToMapList(String queryString, Map<String, Object> values,
int firstResult, int maxResults) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
query.setFirstResult(firstResult).setMaxResults(maxResults);
return query.list();
}
public Map<String, Object> findBySqlUniqueToMap(String queryString, Object... values) {
Query query = createSQLQuery(queryString, values);
query.setResultTransformer(Transformers.ALIAS_TO_ENTITY_MAP);
return (Map<String, Object>) query.uniqueResult();
}
public List<T> findEqualByEntity(T entity, String... propertyNames) {
Criteria criteria = this.createCriteria();
Example exam = Example.create(entity);
exam.excludeZeroes();
String[] defPropertys = getSessionFactory().getClassMetadata(this.typeClass()).getPropertyNames();
if (propertyNames != null)
for (String defProperty : defPropertys) {
int ii = 0;
for (ii = 0; ii < propertyNames.length; ++ii) {
if (defProperty.equals(propertyNames[ii])) {
criteria.addOrder(Order.asc(defProperty));
break;
}
}
if (ii == propertyNames.length) {
exam.excludeProperty(defProperty);
}
}
criteria.add(exam);
return criteria.list();
}
public List<T> findLikeByEntity(T entity, String[] propertyNames) {
Criteria criteria = this.createCriteria();
for (String property : propertyNames) {
try {
Object value = PropertyUtils.getProperty(entity, property);
if (value instanceof String) {
criteria.add(Restrictions.like(property, (String) value, MatchMode.ANYWHERE));
criteria.addOrder(Order.asc(property));
} else {
criteria.add(Restrictions.eq(property, value));
criteria.addOrder(Order.asc(property));
}
} catch (Exception ex) {
}
}
return criteria.list();
}
public int executeSql(String queryString, Map<String, Object> values) {
Query query = createSQLQuery(queryString, values);
return query.executeUpdate();
}
public int executeSql(String queryString, Object... values) {
Query query = createSQLQuery(queryString, values);
return query.executeUpdate();
}
public boolean isCacheable() {
return cacheable;
}
public void setCacheable(boolean cacheable) {
this.cacheable = cacheable;
}
public void saveOrUpdateAll(Collection<T> entities) {
super.getHibernateTemplate().saveOrUpdateAll(entities);
/* Session session = getCurrentSession();
for (Iterator it = entities.iterator(); it.hasNext(); session.saveOrUpdate(it.next()))
;*/
}
protected Connection getConnectionByDataSource() throws SQLException {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:/applicationContext*.xml");
DataSource dataSource = (DataSource) ctx.getBean("dataSource");
Connection connection = dataSource.getConnection();
connection.setAutoCommit(false);
return connection;
}
@SuppressWarnings("deprecation")
protected Connection getConnection() throws SQLException {
return getCurrentSession().connection();
}
public void deleteObject(Object entity) {
Assert.notNull(entity);
getHibernateTemplate().delete(entity);
}
public void saveObject(Object entity) {
Assert.notNull(entity);
getHibernateTemplate().save(entity);
}
public void updateObject(Object entity) {
Assert.notNull(entity);
getHibernateTemplate().update(entity);
}
protected PreparedStatement setParams(PreparedStatement ps, Object... values) throws SQLException {
for (int i = 0; i < values.length; i++) {
//System.out.println(values[i]);
ps.setObject(i + 1, values[i]);
}
return ps;
}
/**
* 创建Criteria对象，带排序字段与升降序字段.
*
* @see #createCriteria(Class,Criterion[])
*/
protected Criteria createCriteria(String orderBy, boolean isAsc, Criterion... criterions) {
Assert.hasText(orderBy);
Criteria criteria = createCriteria(criterions);
if (isAsc)
criteria.addOrder(Order.asc(orderBy));
else
criteria.addOrder(Order.desc(orderBy));
return criteria;
}
protected Class<T> typeClass() {
return (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
}
/**
* 根据主键删除记录
* @param id
*/
public void removeById(ID id) {
/* Map map = getSessionFactory().getAllClassMetadata();
SingleTableEntityPersister p = (SingleTableEntityPersister) map.get(entityClass.getName());
String idName = p.getIdentifierPropertyName();
*/
String hql = "delete from " + entityClass.getName() + " where " + getIdName(entityClass) + "=?";
getHibernateTemplate().bulkUpdate(hql, id);
}
/**
* 根据主键删除记录,主键默认为ID
* @param id
*/
public void deleteById(ID id) {
String hql = "delete from " + entityClass.getName() + " where id=?";
getHibernateTemplate().bulkUpdate(hql, id);
}
/**
* 获取全部对象,带排序字段与升降序参数.
*/
public List<T> getAll(Class entityClass, String orderBy, boolean isAsc) {
Assert.hasText(orderBy);
if (isAsc)
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(entityClass).addOrder(Order.asc(orderBy)));
else
return getHibernateTemplate().findByCriteria(
DetachedCriteria.forClass(entityClass).addOrder(Order.desc(orderBy)));
}
/**
* 判断对象某列的值在数据库中不存在重复
*
* @param names
* 在POJO里相对应的属性名,列组合时以逗号分割<br>
* 如"name,loginid,password"
*/
public boolean isNotUnique(T entity, String... names) {
Criteria criteria = createCriteria(entityClass).setProjection(Projections.rowCount());
try {
for (String name : names) {
criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name)));
}
String idName = getIdName(entityClass);
if (idName != null) {
Object id = PropertyUtils.getProperty(entity, idName);
// 如果是update,排除自身
if (id != null)
criteria.add(Restrictions.not(Restrictions.eq(idName, id)));
}
criteria.setCacheable(true);
} catch (Exception e) {
logger.error(e.getMessage());
return false;
}
return Convert.castToNumber(criteria.uniqueResult()).intValue() > 0;
}
public boolean isunique(T entity, String... names) {
Criteria criteria = createCriteria(entityClass).setProjection(Projections.rowCount());
try {
for (String name : names) {
criteria.add(Restrictions.eq(name, PropertyUtils.getProperty(entity, name)));
}
//criteria.setCacheable(true);
} catch (Exception e) {
return false;
}
return Convert.castToNumber(criteria.uniqueResult()).intValue() > 0;
}
/**
* 批量更新业务对象
* add by chenmk 2008.01.22
*
* @param objList
*/
public void updateBatch(List<T> objList) {
if (objList == null || objList.size() == 0)
return;
int i = 0;
for (T obj : objList) {
update(obj);
/*
* 将本批插入的对象立即写入数据库并释放内存
* 如果要将很多对象持久化，你必须通过经常的调用 flush() 以及稍后调用 clear() 来控制第一级缓存的大小 *
*/
if (++i % 20 == 0) {
flush();
clear();
}
}
}
/**
* 批量保存
* add by chenmk 2008.01.22
*
* @param objList
*/
public void saveBatch(List<T> objList) {
if (objList == null || objList.size() == 0)
return;
int i = 0;
for (T obj : objList) {
save(obj);
/*
* 将本批插入的对象立即写入数据库并释放内存
* 如果要将很多对象持久化，你必须通过经常的调用 flush() 以及稍后调用 clear() 来控制第一级缓存的大小 *
*/
if (++i % 20 == 0) {
flush();
clear();
}
}
}
public void saveAll(Collection<T> entities) {
for (Iterator it = entities.iterator(); it.hasNext(); getCurrentSession().save(it.next()))
;
}
public List<T> findByPropertyLike(String propertyName, String value) {
return findByPropertyLike(entityClass, propertyName, value);
}
public Page<T> getAll(Page<T> page) {
// TODO Auto-generated method stub
return null;
}
public int getCount(String className) {
String queryString = "select count(*) from " + className;
Object uniqueResult = createQuery(queryString).uniqueResult();
return Convert.toInt(uniqueResult);
}
protected Query getCountQuery() {
String queryString = "select count(*) from " + getTableName();
return createQuery(queryString);
}
private String getTableName() {
return typeClass().getSimpleName();
}
public int getCount() {
return getCount(getTableName());
}
public int getCount(String propertyName, Object value) {
String queryString = "select count(*) from " + getTableName() + " as model where model." + propertyName
+ "= ? ";
List result = getHibernateTemplate().find(queryString, value);
return ((Long) result.get(0)).intValue();
}
public int getCount(String[] propertyNames, Object[] values) {
String queryString = "select count(*) from " + getTableName() + " as model where ";
for (String propertyName : propertyNames) {
queryString += " model." + propertyName + "=? and";
}
queryString = StringUtils.removeEnd(queryString, "and");
List result = getHibernateTemplate().find(queryString, values);
return ((Long) result.get(0)).intValue();
}
public List<T> findIn(String propertyName, Object[] value) {
DetachedCriteria date = DetachedCriteria.forClass(typeClass());
date.add(Restrictions.in(propertyName, value));
return getHibernateTemplate().findByCriteria(date);
}
public Integer countByPropertyName(String propertyName) {//上面的用法
DetachedCriteria criteria = createDetachedCriteria();
criteria.setProjection(Projections.count(propertyName));
return getRowCount(criteria);
}
public Integer countByHql(String hql, Object... values) {
Object cnt = createQuery(hql, values).uniqueResult();
return Convert.toInt(cnt);
}
public T merge(T entity) {
return (T) super.getHibernateTemplate().merge(entity);
}
/**
* 将 HQL 翻译成 SQL 语句
* @param originalHql
* @param sessionFactory
* @return
* @throws Exception
*/
protected String transHQL(String originalHql, SessionFactory sessionFactory) {
QueryTranslatorImpl queryTranslator = new QueryTranslatorImpl(originalHql, originalHql, Collections.EMPTY_MAP,
(org.hibernate.engine.SessionFactoryImplementor) sessionFactory);
queryTranslator.compile(Collections.EMPTY_MAP, false);
return queryTranslator.getSQLString();
}
/**
* 调用 SP 语句，Add By D.Q.Wang
* @param spName
* @param prmsCount
* @param inPrms
* @return
*/
public String[] spCall(final String spName, final int prmsCount, final String[] inPrms) {
return (String[]) getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) {
int inPrmsCount = inPrms.length;
int outPrmsCount = prmsCount - inPrmsCount;
String prmListStr = "";
for (int i = 0; i < prmsCount; i++)
prmListStr += ",?";
if (prmListStr.length() > 0)
prmListStr = prmListStr.substring(1);
String[] outPrms = new String[outPrmsCount];
try {
Connection conn = session.connection();
CallableStatement cstmt = conn.prepareCall("{call " + spName + "(" + prmListStr + ")}");
int index = 1;
for (; index <= inPrmsCount; index++)
cstmt.setString(index, inPrms[index - 1]);
for (; index <= prmsCount; index++)
cstmt.registerOutParameter(index, java.sql.Types.VARCHAR);
cstmt.execute();
for (int i = 0; i < outPrms.length; i++)
outPrms[i] = cstmt.getString(inPrmsCount + i + 1);
} catch (Exception ex) {
logger.error(ex.getMessage());
}
return outPrms;
}
});
}
public int updateEntityByQuery(String queryString, Map<String, Object> values) {
Query query = createQuery(queryString, values);
return query.executeUpdate();
}
public int updateEntityByQuery(String queryString, Object... values) {
Query query = createQuery(queryString, values);
return query.executeUpdate();
}
public boolean isuniqueAny(T entity, String... names) {
String queryString = "select count(*) from " + getTableName() + " where ";
try {
for (String name : names) {
queryString += name + "='" + PropertyUtils.getProperty(entity, name) + "' or ";
}
queryString = StringUtils.substringBeforeLast(queryString, "or");
} catch (Exception e) {
return false;
}
System.out.println(queryString);
return countByHql(queryString) >= 1;
}
}
function ClassA(sColor) {
this.color = sColor;
this.sayColor = function () {
alert(this.color);
};
}第一种方式:对象冒充function ClassB(sColor, sName) {
this.newMethod = ClassA; //注意这里
this.newMethod(sColor);
delete this.newMethod;
this.name = sName;
this.sayName = function () {
alert(this.name);
};
}
jQuery的bind的函数在实际应用其实不是特别多，只是他可以绑定一个事件，但不会即时触发，也可以通过unbind来解除绑定。
在没有看到这篇 文章之前，我一直不知道原来bind也可以有命名空间。事实上，我看完这篇文章后，再去翻了一下手册，也才发现了一点点的注释。但手册也仅仅是一句话就带 过去了。没有过多的深究，或许他认为命名空间这玩意很简单，没有必要多解释？
先看手册，由于bind方法有三个参数(type,[data],fn)，所以手册上这么介绍:
很多前端开发工程师喜欢使用HTML的属性来存储数据：
$('selector').attr('alt', 'data being stored');
//之后可以这样读取数据:
$('selector').attr('alt');使用”alt”属性来作为参数名存储数据其实对于HTML来说是不符合语义的，我们可以使用jQuery的data方法来为页面中的某个元素存储数据,使用data方法可以避免在DOM中存储数据
非用户行为弹出窗口会被浏览器拦截，现改为用form表单提交方式，即可突破所有浏览器（在safari4、chrome、ie6-8、 firefox3）的限制。
var _taction = 'http://www.baidu.com';
var _FORM = document.createElement('form');
document.body.appendChild(_FORM);
_FORM.action = _taction;
_FORM.method = 'get';
_FORM.target = '_blank';
_FORM.submit();
<select id="bag" > <option value="178">女式</option> <option value="177">男式</option> <option value="179">通用</option> </select>
jQuery一般是通过val()方法来选中select
从水水的博客看到了这篇关于magento1.4中关于widget的操作, 确实很好很强大/p>
Widget是magento1.4新增的功能之一，Widget这 个词直译过来是小挂件，小装置的意思，在Magento中，Widget是提供给CMS的一个加强功能，可以很方便的加入各种 动态内容，比如最近查看商品，或指向某个商品的链接。
摘要：现代网站和web应用程序趋向于依赖客户端的大量的javascript来提供丰富的交互。特别是通过不刷新页面的异步请求来返回数据或从服务器端的脚本（或数据系统）中得到响应。在这篇文章中，你将会了解到javascript框架如何更快、更方便的创建互动性强、响应快得网站和web应用程序。
导言：JavaScript是一种面向对象的脚本语言，一直以来用作Web浏览器应用程序客户端脚本接口的选择。JavaScript允许Web开发人员编程与网页上的对象的工作,为凭空操作这些对象提供了一个平台。当JavaScript最初推出时，它通常用来提供一些微不足道的功能，如时钟、在浏览器状态栏中滚动文本。另外一个常用特色就是“rollover link”,即当用户的鼠标滑过对象时，其文本的颜色或背景图片发生改变。然而，近年来Ajax为网络编程带来了全新的互动，JavaScript几经发展变得更加有用。在Ajax之前，任何服务器端处理或数据库访问都需要整页面被“刷新”或由浏览器呈现新的页面。这不仅缓慢，令用户失望，而且也浪费了带宽和资源。
package com.wlh.hibernate;
import java.text.SimpleDateFormat;
import java.util.Date;
public class Test {
//返回2007-01-01到2007-03-01的一个随机日期
public static void main(String []args){
Date randomDate=randomDate("2007-01-01","2007-03-01");
System.out.println(randomDate.toString());
}
/**
* 获取随机日期
* @param beginDate 起始日期，格式为：yyyy-MM-dd
* @param endDate 结束日期，格式为：yyyy-MM-dd
* @return
*/
private static Date randomDate(String beginDate,String endDate ){
try {
SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
Date start = format.parse(beginDate);//构造开始日期
Date end = format.parse(endDate);//构造结束日期
//getTime()表示返回自 1970 年 1 月 1 日 00:00:00 GMT 以来此 Date 对象表示的毫秒数。
if(start.getTime() >= end.getTime()){
return null;
}
long date = random(start.getTime(),end.getTime());
return new Date(date);
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private static long random(long begin,long end){
long rtn = begin + (long)(Math.random() * (end - begin));
//如果返回的是开始时间和结束时间，则递归调用本函数查找随机值
if(rtn == begin || rtn == end){
return random(begin,end);
}
return rtn;
}
}