freemaker+dwr+springmvc的配置

2020-05-31 原文

freemaker的配置文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
<beans>
<bean id="freeMarkerConfigurer" class="org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer">
<property name="freemarkerSettings">
<props>
<prop key="default_encoding">UTF-8</prop>
<prop key="date_format">yyyy-MM-dd</prop>
<prop key="time_format">HH:mm</prop>
<prop key="datetime_format">yyyy-MM-dd HH:mm</prop>
<prop key="number_format">#.########</prop>

<prop key="template_exception_handler">ignore</prop>

<prop key="classic_compatible">true</prop>
<prop key="auto_import">static/comm/commons.ftl as page</prop>
</props>
</property>
<property name="templateLoaderPath" value="/" />
</bean>

<bean class="com.util.WebApplicationContextUtil" /> 获取工具类
</beans>

spring核心文件扫描控制层

扫描任务调度

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:task="http://www.springframework.org/schema/task"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task.xsd">

<context:component-scan base-package="com.task"/>
<task:executor id="executor" pool-size="15"/> 任务调度并发数
<task:scheduler id="scheduler" pool-size="30"/> 任务调度的最大任务数量
<task:annotation-driven executor="executor" scheduler="scheduler"/>
</beans>

dwr的扫描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:dwr="http://www.directwebremoting.org/schema/spring-dwr"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.directwebremoting.org/schema/spring-dwr http://www.directwebremoting.org/schema/spring-dwr-3.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<dwr:configuration/>
<dwr:annotation-scan base-package="com.dwr" scanDataTransferObject="false"/>
</beans>

注解的方式获取实体

<context:annotation-config /> 注解方式使用实体bean
<context:component-scan base-package="com..dao.jdbcimpl" />

<property name="packagesToScan">

<bean>的bean的形式配置数据源》
<list>
<value>com.**.po</value>
</list>
</property>

<配置sessionFactory>

<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"></property>
</bean>
<tx:annotation-driven transaction-manager="transactionManager"/>

三个规范文件

* DAOBean的命名规则是将DAO的首子母大写并将DAO_IMPLEMENT_SUFFIX后缀去掉
*/
public class DAOBeanNameGenerator implements BeanNameGenerator {
private final Log LOG = LogFactory.getLog(getClass());
private static final String DAO_IMPLEMENT_SUFFIX = "Implement";

public String generateBeanName(BeanDeFinition deFinition,BeanDeFinitionRegistry registry) {
String beanName = StringUtils.capitalize(StringUtils.unqualify(deFinition.getBeanClassName()));
beanName = beanName.endsWith(DAO_IMPLEMENT_SUFFIX)?beanName.substring(0,beanName.length()-DAO_IMPLEMENT_SUFFIX.length()):beanName;
LOG.info("generateBeanName:"+beanName);
return beanName;
}

/**
* Sequence的命名规则是将bean的大写字母用_分开，小写字母转大写，最后加上_S的后�?
*/
public class BaseBeanSequenceGenerator extends SequenceGenerator {

@Override
public void configure(Type type,Properties params,Dialect dialect) throws MappingException {
//System.out.println("configure("+type+","+params+","+dialect);
if(!params.containsKey(SequenceGenerator.SEQUENCE)) {
String tableName = params.getProperty("identity_tables");
if(tableName==null) tableName = params.getProperty("target_table");
if(tableName==null) throw new MappingException("unkNows table name:"+params);
params.setProperty(SequenceGenerator.SEQUENCE,tableName+"_S");
}
super.configure(type,params,dialect);
}

public class BaseBeanNamingStrategy extends EJB3NamingStrategy {
private static final long serialVersionUID = -5742401920577663212L;
public static final NamingStrategy INSTANCE = new BaseBeanNamingStrategy();

@Override
public String propertyToColumnName(String propertyName) {
return addUnderscores(propertyName);
}

@Override
public String classtoTableName(String className) {
return addUnderscores(className.replace("Bean",""));
}

private static String addUnderscores(String name) {
StringBuilder sb = new StringBuilder(name.replace('.','_'));
int i = 0;
while(i < sb.length()) {
if(Character.isLowerCase(sb.charat(i++))) {
if(i>2) sb.insert(i-2,'_');
break;
}
}
while(i<sb.length()-1) {
if(Character.isLowerCase(sb.charat(i-1)) && Character.isUpperCase(sb.charat(i)) && Character.isLowerCase(sb.charat(i+1))) {
sb.insert(i++,'_');
}
i++;
}
return sb.toString().toupperCase();
}

/**
* Entity的表名和字段名命名规则是将大写字母用_分开，小写字母转大写，结尾的Bean去掉
*/
public class BaseBeanNamingStrategy extends EJB3NamingStrategy {
private static final long serialVersionUID = -5742401920577663212L;
public static final NamingStrategy INSTANCE = new BaseBeanNamingStrategy();

package com.guu.uurms.dao.base;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;

/**
* DAO的base类定义通用的抽象方法
*/
public interface BaseDAO<T extends Serializable> {
/**
* 根据sid得到对像
*
* @param sid
* @return
*/
public abstract T getBeanBySid(Long sid);

/**
* 保存对像
*
* @param bean
* @return
*/
public abstract void saveBean(T obj);

/**
* 更新对像
*
* @param obj
* @return
*/
public abstract void updateBean(T obj);

/**
* 删除对像
*
* @param obj
* @return
*/
public abstract void deleteBean(T obj);

/**
* 根据条件查找记录并分页
*
* @param eqName
* @param eqValue
* @param currypage
* @param pagesize
* @return
*/
public abstract List<T> getBeanListByEq(String eqName,Object eqValue,int currypage,int pagesize);

/**
* 根据条件查找记录并分页排序
*
* @param eqName
* @param eqValue
* @param currypage
* @param pagesize
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(String eqName,int pagesize,String order,boolean asc);

/**
* 根据条件获取记录总数
*
* @param eqName
* @param eqValue
* @return
*/
public abstract long getBeanCountByEq(String eqName,Object eqValue);

/**
* 根据条件查找记录并分页
*
* @param eq
* @param currypage
* @param pagesize
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,Object> eq,int pagesize);

/**
* 根据条件查找记录并分页排序
*
* @param eq
* @param currypage
* @param pagesize
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,boolean asc);

/**
* 根据条件获取记录总数
*
* @param eq
* @return
*/
public abstract long getBeanCountByEq(Map<String,Object> eq);

/**
* 查找记录并分页
*
* @param currypage
* @param pagesize
* @return
*/
public abstract List<T> getBeanList(int currypage,int pagesize);

/**
* 查找记录并分页排序
*
* @param currypage
* @param pagesize
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanList(int currypage,boolean asc);

/**
* 获取记录总数
*
* @return
*/
public abstract long getBeanCount();

/**
* 查找所有记录
*
* @return
*/
public abstract List<T> getBeanList();

/**
* 查找所有记录并排序
*
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanList(String order,boolean asc);

/**
* 根据条件查找记录
*
* @param eqName
* @param eqValue
* @return
*/
public abstract List<T> getBeanListByEq(String eqName,Object eqValue);

/**
* 根据条件查找记录并排序
*
* @param eqName
* @param eqValue
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(String eqName,boolean asc);

/**
* 根据条件查找记录
*
* @param eq
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,Object> eq);

/**
* 根据条件查找记录并排序
*
* @param eq
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,boolean asc);

/**
* 根据条件得到唯一对像
*
* @param eqName
* @param eqValue
* @return
*/
public abstract T getBeanByEq(String eqName,Object eqValue);

/**
* 根据条件得到唯一对像
*
* @param eq
* @return
*/
public abstract T getBeanByEq(Map<String,Object> eq);

/**
* 根据sid删除记录
* @param sid
*/
public abstract void deleteBeanBySid(Long sid);

/**
* 根据sid列表删除记录
* @param sid
* @return 成功删除的记录数
*/
public abstract int deleteBeanBySid(List<Long> sid);

/**
* 根据sid数组删除记录
* @param sid
* @return 成功删除的记录数
*/
public abstract int deleteBeanBySid(String[] sid);

/**
* 根据条件删除记录
*
* @param eqName
* @param eqValue
* @return
*/
public abstract int deleteBeanByEq(String eqName,Object eqValue);

/**
* 根据条件删除记录
* @param properties key是字段名，value是字段值，如果value是List则以in的方式判断，否则以eq的方式判断
* @return 成功删除的记录数
*/
public abstract int deleteBeanByProperties(Map<String,Object> properties);

/**
* 根据条件查找记录的总数
* @param param
* @param value
* @return
*/
public abstract int getBeanCountByIn(String param,Collection value);

/**
* 根据条件查找记录
* @param param
* @param value
* @return
*/
public abstract List<T> getBeanListByIn(String param,Collection value);

/**
* 根据条件查找记录并分页
* @param param
* @param value
* @param cpage
* @param pagesize
* @return
*/
public abstract List<T> getBeanListByIn(String param,Collection value,int cpage,int pagesize);

/**
* 根据条件查找记录并按照条件排序
* @param param
* @param value
* @param cpage
* @param pagesize
* @param Order
* @param asc
* @return
*/
public abstract List<T> getBeanListByIn(String param,String Order,boolean asc);

/**
* 查找记录并分页排序
* @param currypage
* 小于1则不分页
* @param pagesize
* @param order
* 为null或length为0则不排序
* @param asc
* @return
*/
public abstract List<T> getBeanList(int currypage,String[] order,boolean[] asc);

/**
* 查找记录并排序
* @param order
* 为null或length为0则不排序
* @param asc
* @return
*/
public abstract List<T> getBeanList(String[] order,boolean[] asc);

/**
* 根据条件查找记录并排序
* @param eqName
* 为null或""则不判断
* @param eqValue
* @param currypage
* 小于1则不分页
* @param pagesize
* @param order
* 为null或length为0则不排序
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(String eqName,boolean[] asc);

/**
* 根据条件查找记录并排序
*
* @param eq
* @param order
* 为null或length为0则不排序
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,boolean[] asc);

/**
* 根据条件查找记录并排序
*
* @param eq
* @param currypage
* 小于1则不分页
* @param pagesize
* @param order
* 为null或length为0则不排序
* @param asc
* @return
*/
public abstract List<T> getBeanListByEq(Map<String,boolean[] asc);

/**
* 根据sid查找记录
* @param sid
* @return
*/
public abstract List<T> getBeanListBySid(List<Long> sid);

/**
* 根据条件不区分大小写模糊查询记录并排序
* @param ilinkName
* @param ilinkValue
* @param currypage
* @param pagesize
* @param order
* @param asc
* @return
*/
public abstract List<T> getBeanListByIlink(String ilinkName,String ilinkValue,boolean asc);

public List<T> getListByIlink(Map<String,Object> ilink,String ordername,boolean asc);

public List<T> getListByEqAndIlink(Map<String,Map<String,boolean asc);

/**
* 根据条件不区分大小写模糊查询记录数
* @param ilinkName
* @param ilinkValue
* @return
*/
public abstract long getBeanCountByIlink(String ilinkName,String ilinkValue);

public abstract long getCountByEqAndIlink(Map<String,Object> ilink);

/**
* 查找所有记录并按照指定的key和value字段返回结果
* @param mapKey 保存在key的字段
* @param mapValue 保存在value的字段
* @return
*/
public abstract Map getBeanMap(String mapKey,String mapValue);

/**
* 根据条件查询记录并按照指定的key和value字段返回结果
* @param mapKey 保存在key的字段
* @param mapValue 保存在value的字段
* @return
*/
public abstract Map getBeanMap(String mapKey,String mapValue,boolean asc);

/**
* 根据条件得到唯一对像，并且将其它重复的记录删除
* @param eqName
* @param eqValue
* @return
*/
public abstract T getBeanBySidAndDeleteRepeat(String eqName,Object eqValue);

public abstract long getBeanCountByMultiCondition(Object[][] conditionList);

public abstract List<T> getBeanListByMultiCondition(Object[][] conditionList,Object[][] orderlist);

}

package com.guu.uurms.dao.base;

import java.io.Serializable;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.sqlException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Pattern;

import javax.annotation.postconstruct;
import javax.annotation.Resource;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Projection;
import org.hibernate.criterion.ProjectionList;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.hibernate.criterion.Restrictions;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.guu.uurms.po.base.BaseBean;

/**
* DAO的base实现类实现BaseDAO的抽象方法及通用方法
*
* @author 华理德
* @date 2009-04-09
*/
@SuppressWarnings("unchecked")
public abstract class BaseDAOImplement<T extends Serializable> extends HibernateDaoSupport implements BaseDAO<T> {
private static final Log LOG = LogFactory.getLog(BaseDAOImplement.class);
private Pattern ilikePattern = Pattern.compile("[_%]");
protected Class<T> bean;

@postconstruct
protected void setBean() throws ClassNotFoundException {
String className = getClass().getSimpleName();
try {
System.out.println(BaseBean.class.getPackage().getName().replace(".base","")+"."+className.replace("DAOImplement","Bean"));
bean = (Class<T>)Class.forName(BaseBean.class.getPackage().getName().replace(".base","Bean"));
} catch(ClassNotFoundException e) {
throw new ClassNotFoundException("BaseDAOImplement无法加载"+getClass().getName()+"的Bean["+e.getMessage()+"]");
}
}

protected Class<T> getBean() {
return bean;
}

@Resource
public void injectSessionFactory(SessionFactory sessionFactory) {
setSessionFactory(sessionFactory);
}

/*
* =======================================================================
* 实现DAOBase的抽象方法
* =======================================================================
*/
public String getIdName() {
return "sid";
}

public void deleteBean(T bean) {
deleteObject(bean);
}

public T getBeanByEq(Map<String,Object> eq) {
return getobjectByEq(eq);
}

public T getBeanByEq(String eqName,Object eqValue) {
return getobjectByEq(eqName,eqValue);
}

public T getBeanBySid(Long sid) {
return getBeanByEq(getIdName(),sid);
}

public List<T> getBeanList(int currypage,int pagesize) {
return getListByEq(null,currypage,pagesize,getIdName(),false);
}

public List<T> getBeanList(int currypage,boolean asc) {
return getListByEq(null,order,asc);
}

public List<T> getBeanList() {
return getListByEq(null,false);
}

public List<T> getBeanList(String order,asc);
}

public List<T> getBeanListByEq(Map<String,int pagesize) {
return getListByEq(eq,false);
}

public List<T> getBeanListByEq(Map<String,boolean asc) {
return getListByEq(eq,Object> eq) {
return getListByEq(eq,asc);
}

public List<T> getBeanListByEq(String eqName,int pagesize) {
return getListByEq(getMap(eqName,eqValue),false);
}

public List<T> getBeanListByEq(String eqName,boolean asc) {
return getListByEq(getMap(eqName,Object eqValue) {
return getListByEq(getMap(eqName,asc);
}

public long getBeanCount() {
return getCountByEq(null);
}

public long getBeanCountByEq(Map<String,Object> allEq) {
return getCountByEq(allEq);
}

public long getBeanCountByEq(String eqName,Object eqValue) {
return getCountByEq(getMap(eqName,eqValue));
}

public void saveBean(T bean) {
saveObject(bean);
}

public void updateBean(T bean) {
updateObject(bean);
}

public void deleteBeanBySid(Long sid) {
deleteObject(getIdName(),sid);
}

public int deleteBeanBySid(List<Long> sid) {
return deleteObject(getIdName(),sid);
}

public int deleteBeanBySid(String[] sid) {
if(sid==null || sid.length==0) return 0;
List<Long> value = new ArrayList<Long>();
for(String id : sid) {
value.add(Long.valueOf(id));
}
return deleteObject(getIdName(),value);
}

public List<T> getBeanList(int currypage,boolean[] asc) {
return getListByEq(null,asc);
}

public List<T> getBeanList(String[] order,
String[] order,boolean[] asc) {
return getListByEq(eqName,eqValue,asc);
}

public List<T> getBeanListByEq(Map<String,boolean[] asc) {
return getListByEq(eq,asc);
}

public int deleteBeanByEq(String eqName,Object eqValue) {
return deleteObject(eqName,eqValue);
}

public int deleteBeanByProperties(final Map<String,Object> properties) {
if(properties == null || properties.isEmpty()) {
return 0;
} else {
return (Integer)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
StringBuilder hql = new StringBuilder();
hql.append("delete ");
hql.append(getBean().getName());
hql.append(" where ");
for(Iterator<String> iter = properties.keySet().iterator(); iter.hasNext();) {
String key = iter.next();
Object value = properties.get(key);
hql.append(key);
if(value==null) {
hql.append(" is null");
} else if(value instanceof Collection) {
hql.append(" in (:");
hql.append(key);
hql.append(")");
} else {
hql.append("=:");
hql.append(key);
}
if(iter.hasNext()) hql.append(" and ");
}
Query query = session.createquery(hql.toString());
query.setProperties(properties);
return query.executeUpdate();
}
});
}
}

public List<T> getBeanListBySid(List<Long> sid) {
return getListByIn(getIdName(),sid,null,false);
}

public List<T> getBeanListByIlink(String ilinkName,boolean asc) {
return getListByIlink(ilinkName,ilinkValue,asc);
}

public long getBeanCountByIlink(String ilinkName,String ilinkValue) {
return getCountByIlink(ilinkName,ilinkValue);
}

public Map getBeanMap(final String mapKey,final String mapValue) {
List<Object[]> result = getHibernateTemplate().find("select "+mapKey+","+mapValue+" from "+getBean().getSimpleName());
Map map = new HashMap();
for(Object[] o:result) {
map.put(o[0],o[1]);
}
return map;
}

public Map getBeanMap(final String mapKey,final String mapValue,final Map<String,final int currypage,final int pagesize,final String order,final boolean asc) {
List<Object[]> result = getHibernateTemplate().executeFind(new HibernateCallback() {

public Object doInHibernate(Session session) throws HibernateException,sqlException {
Criteria c = session.createCriteria(getBean());
if(eq != null && !eq.isEmpty()) {
c.add(Restrictions.allEq(eq));
}
if(currypage > 0) {
c.setFirstResult((currypage - 1) * pagesize);
c.setMaxResults(pagesize);
}
if(order != null) {
c.addOrder(asc?Order.asc(order):Order.desc(order));
}
c.setProjection(Projections.projectionList().add(Property.forName(mapKey)).add(Property.forName(mapValue)));
return c.list();
}});
Map map = new HashMap();
for(Object[] o:result) {
map.put(o[0],o[1]);
}
return map;
}

public T getBeanBySidAndDeleteRepeat(String eqName,Object eqValue) {
List<T> list = getListByEq(eqName,1,1000,true);
if(list.isEmpty()) return null;
if(list.size()>1) {
for(int i = 1; i<list.size(); i++) {
deleteBean(list.get(i));
}
}
return list.get(0);
}

/*
* =======================================================================
* 提供给所有继承该类的子类调用的方法
* =======================================================================
*/
/**
* 根据多种混合的条件（如大于，等于，小于，不等于，包含）分页获取LIST
*
* @param conditionList
* @param currypage
* @param pagesize
* @param orderName
* @param asc
* @return
* @author 杨浚
*/
protected List<T> getListByMultiCondition(final Object[][] conditionList,final String orderName,final boolean asc) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
Criteria cr = session.createCriteria(getBean());
for(Object[] condition : conditionList) {
addCriteriaCondition(cr,condition);
}
Order order = null;
if(asc) {
order = Order.asc(orderName);
} else {
order = Order.desc(orderName);
}
//order=asc?Order.asc(orderName):Order.desc(orderName);
cr.addOrder(order);
if(currypage!=0 && pagesize !=0){
cr.setMaxResults(pagesize);
cr.setFirstResult((currypage - 1) * pagesize);
}
return cr.list();
}
});
}

/**
* 根据多种混合的条件（如大于，等于，小于，不等于，包含）分页获取LIST 当pagesize<=0时，不进行分页
*
* @param conditionList
* @param currypage
* @param pagesize
* @param orderName
* @param asc
* @return
* @author 杨浚
*/
public List<T> getBeanListByMultiCondition(final Object[][] conditionList,final Object[][] orderlist) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,condition);
}
addCriteriaOrder(cr,orderlist);
if(currypage!=0 && pagesize !=0) {
cr.setMaxResults(pagesize);
cr.setFirstResult((currypage - 1) * pagesize);
}
return cr.list();
}
});
}

/**
* 把查询条件加入Criteria中。
*
* @param cr
* @param condition
* @author 杨浚
*/
private void addCriteriaCondition(Criteria cr,Object[] condition) {
try {
if(condition!=null&&condition[0] != null && !condition[0].equals("")) {
Method[] methods = Restrictions.class.getmethods();
for(Method mth : methods) {
boolean isThisMethod = false;
if(mth.getName().equals((String)condition[0])) {
isThisMethod = true;
Class[] parameters = mth.getParameterTypes();
try {
if(parameters.length+1!=condition.length){
isThisMethod=false;
}else{
for(int i = 0; i < parameters.length; i++) {
if(!parameters[i].isinstance(condition[i+1])) {
isThisMethod = false;
}
}
}

} catch(Exception e) {
isThisMethod = false;
LOG.error("exception,but nvm!",e);
}
}
if(isThisMethod) {
Object[] desArray = new Object[condition.length - 1];
System.arraycopy(condition,desArray,condition.length - 1);
Criterion re = (Criterion)mth.invoke(null,desArray);
cr.add(re);
return;
}
}
}
} catch(Exception e) {
LOG.error("把查询条件加入Criteria中出错",e);
}
}

/**
* 把排序条件放入Criteria中，其中[i][1]为一个boolean，true表示升序，false表示降序，[i][0]为排序条件
*
* @param cr
* @param order
* @author 杨浚
*/
private void addCriteriaOrder(Criteria cr,Object[][] order) {
for(int i = 0; i < order.length; i++) {
cr.addOrder((Boolean)order[i][1]?Order.asc((String)order[i][0]):Order.desc((String)order[i][0]));
}
}

/**
* 根据多种混合的条件（如大于，等于，小于，不等于，包含）获得结果总数
*
* @param conditionList
* @return
* @author 杨浚
*/
public long getBeanCountByMultiCondition(final Object[][] conditionList) {
return (Long)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,condition);
}
return cr.setProjection(Projections.rowCount()).uniqueResult();
}
});
}

/**
* 根据混合的条件和范围获得结果
* @author 杨浚
* @param conditionList
* @param projectionList
* @param singleResult
* @return
*/
protected T getResultByMultiCondition(final Object[][] conditionList,final Object[] projectionList,final boolean singleResult){
return (T)getHibernateTemplate().executeWithNativeSession(new HibernateCallback(){

public Object doInHibernate(Session sess)
throws HibernateException,sqlException {
Criteria cr=sess.createCriteria(getBean());
for(Object[] condition : conditionList) {
addCriteriaCondition(cr,condition);
}
cr.setProjection(addProjection(cr,projectionList));
if(singleResult){
return cr.uniqueResult();
}else{
return cr.list();
}
}

});
}

/**
* 把查询的范围加入criteria中
* @param cr
* @param projection
*/
private ProjectionList addProjection(Criteria cr,Object[] projection){
ProjectionList pl=Projections.projectionList();
if(projection!=null && projection[0]!=null && !projection[0].equals("")){
try {
Object[] desArray = new Object[projection.length - 1];
System.arraycopy(projection,projection.length - 1);
Class[] classArray=new Class[desArray.length];
for(int i=0;i<desArray.length;i++){
classArray[i]=desArray[i].getClass();
}
Method method = Projections.class.getmethod((String)projection[0],classArray);

Projection p = (Projection) method.invoke(null,desArray);
pl.add(p);
} catch (SecurityException e) {
LOG.error("addProjection("+cr+","+Arrays.toString(projection)+")",e);
} catch (NoSuchMethodException e) {
LOG.error("addProjection("+cr+",e);
} catch (IllegalArgumentException e) {
LOG.error("addProjection("+cr+",e);
} catch (illegalaccessexception e) {
LOG.error("addProjection("+cr+",e);
} catch (InvocationTargetException e) {
LOG.error("addProjection("+cr+",e);
}
}
return pl;
}

/**
* 根据条件得到对象列表
*
* @param eq
* 为null或empty则不判断
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或""则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-04-01
*/
protected List<T> getListByEq(Map<String,boolean asc) {
return getListByEqAndIlink(eq,ordername,asc);
}

/**
* 根据条件得到对象列表
*
* @param eq
* 为null或empty则不判断
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或length为0则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-04-01
*/
protected List<T> getListByEq(Map<String,String[] ordername,boolean[] asc) {
return getListByEqAndIlink(eq,asc);
}

/**
* 根据条件进行模糊查询
* @param ilinkName
* @param ilinkValue
* @param currypage
* @param pagesize
* @param ordername
* @param asc
* @return
*/
protected List<T> getListByIlink(String name,String value,boolean asc) {
return getListByEqAndIlink(null,getMap(name,value),asc);
}

/**
* 根据条件得到对象列表
*
* @param eq
* 进行相等判断，为null或empty则不判断
* @param ilink
* 进行模糊判断，不区分大小写，为null或empty则不判断
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或length为0则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-09-23
*/
protected List<T> getListByEqAndIlink(final Map<String,final String[] ordername,final boolean[] asc) {
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
Criteria c = session.createCriteria(getBean());
if(eq != null && !eq.isEmpty()) {
c.add(Restrictions.allEq(eq));
}
if(ilink != null && !ilink.isEmpty()) {
for(Iterator<Entry<String,Object>> i = ilink.entrySet().iterator(); i.hasNext();) {
Entry<String,Object> e = i.next();
c.add(Restrictions.ilike(e.getKey(),"%"+ilikePattern.matcher(e.getValue().toString()).replaceAll("\\\\$0")+"%"));
}
}
if(currypage > 0) {
c.setFirstResult((currypage - 1) * pagesize);
c.setMaxResults(pagesize);
}
if(ordername != null && ordername.length>0) {
for(int i = 0; i < ordername.length; i++) {
boolean flag = asc[i];
if(flag) c.addOrder(Order.asc(ordername[i]));
else c.addOrder(Order.desc(ordername[i]));
}
}
return c.list();
}
});
}

protected List<T> getListByEqAndIlink(final Map<String,"%"+ilikePattern.matcher(e.getValue().toString()).replaceAll("\\\\$0")+"%"));
}
}

if(ordername != null && ordername.length>0) {
for(int i = 0; i < ordername.length; i++) {
boolean flag = asc[i];
if(flag) c.addOrder(Order.asc(ordername[i]));
else c.addOrder(Order.desc(ordername[i]));
}
}
return c.list();
}
});
}

/**
* 根据属性得到唯一结果
*
* @param name
* @param value
* @return
*/
protected T getobjectByEq(String name,Object value) {
return getobjectByEq(getMap(name,value));
}

/**
* 根据条件得到唯一结果
*
* @param eq
* @return
*/
protected T getobjectByEq(final Map<String,Object> eq) {
return (T)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
Criteria c = session.createCriteria(getBean());
c.add(Restrictions.allEq(eq));
return c.uniqueResult();
}
});
}

/**
* 根据条件得到对象列表
*
* @param name
* 为null或""则不判断
* @param value
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或""则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-04-09
*/
protected List<T> getListByEq(String name,Object value,boolean asc) {
return getListByEq(getMap(name,asc);
}

/**
* 根据条件得到对象列表
*
* @param name
* 为null或""则不判断
* @param value
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或length为0则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-04-09
*/
protected List<T> getListByEq(String name,boolean[] asc) {
return getListByEq(getMap(name,asc);
}

/**
* 根据条件获取记录数
*
* @param eq
* 为null或empty则不判断
* @return
* @author 华理德
* @date 2009-04-09
*/
protected long getCountByEq(Map<String,Object> eq) {
return getCountByEqAndIlink(eq,null);
}

/**
* 根据条件获取记录数
* @param name
* @param value
* @return
*/
protected long getCountByIlink(String name,String value) {
return getCountByEqAndIlink(null,value));
}

/**
* 根据条件获取记录数
*
* @param eq
* 进行相等判断，为null或empty则不判断
* @param ilink
* 进行模糊判断，不区分大小写，为null或empty则不判断
* @return
* @author 华理德
* @date 2009-04-09
*/
public long getCountByEqAndIlink(final Map<String,Object> ilink) {
return (Long)getHibernateTemplate().executeWithNativeSession(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
DetachedCriteria dc = DetachedCriteria.forClass(getBean());
if(eq != null && !eq.isEmpty()) {
dc.add(Restrictions.allEq(eq));
}
if(ilink != null && !ilink.isEmpty()) {
for(Iterator<Entry<String,Object> e = i.next();
dc.add(Restrictions.ilike(e.getKey(),"%"+e.getValue()+"%"));
}
}
Criteria c = dc.getExecutableCriteria(session);
c.setProjection(Projections.rowCount());
//Object result = c.uniqueResult();
//return result instanceof Integer?result:Integer.valueOf(((Long)result).intValue());
return c.uniqueResult();
}
});
}

/**
* 根据条件获取记录数
*
* @param name
* 为null或""则不判断
* @param value
* @return
* @author 华理德
* @date 2009-04-09
*/
protected long getCountByEq(String name,Object value) {
return getCountByEq(getMap(name,value));
}

/**
* 保存对象
*
* @param obj
* @author 华理德
* @date 2009-04-09
*/
protected void saveObject(T obj) {
getHibernateTemplate().save(obj);
}

/**
* 更新对象
*
* @param obj
* @author 华理德
* @date 2009-04-09
*/
protected void updateObject(T obj) {
getHibernateTemplate().update(obj);
}

/**
* 删除对象
*
* @param obj
* @author 华理德
* @date 2009-04-09
*/
protected void deleteObject(T obj) {
getHibernateTemplate().delete(obj);
}

/**
* 根据条件删除对象
*
* @param name
* @param value
* @return 删除的记录数
* @author 华理德
* @date 2009-04-09
*/
protected int deleteObject(String name,Object value) {
if(value instanceof List) {
return deleteObject(name,(List)value);
} else {
List<Object> list = new ArrayList<Object>();
list.add(value);
return deleteObject(name,list);
}
}

/**
* 根据条件删除对象
*
* @param name
* @param value
* 为null或empty则不处理
* @return 删除的记录数
* @author 华理德
* @date 2009-04-09
*/
protected int deleteObject(final String name,final List<Object> value) {
if(value == null || value.isEmpty()) {
return 0;
} else {
return (Integer)getHibernateTemplate().execute(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
String hql = "delete " + getBean().getName() + " where " + name + " in (:value)";
Query query = session.createquery(hql.toString());
query.setParameterList("value",value);
return query.executeUpdate();
}
});
}
}

/**
* 根据条件删除对象
*
* @param name
* @param value
* 为null或empty则不处理
* @return 删除的记录数
* @author 华理德
* @date 2009-07-28
*/
protected int deleteObject(final String name,final Object[] value) {
if(value == null || value.length == 0) {
return 0;
} else {
return deleteObject(name,Arrays.asList(value));
}
}

/**
* 根据条件得到对象列表
*
* @param name
* @param values
* 进行匹配判断，为null或empty则直接返回空List
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或""则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-07-29
*/
protected List<T> getListByIn(String name,Collection values,boolean asc) {
return getListByIn(name,values,(ordername==null||ordername.equals(""))?null:new boolean[]{asc});
}

/**
* 根据条件得到对象列表
*
* @param name
* @param values
* 进行匹配判断，为null或empty则直接返回空List
* @param currypage
* 小于1则不分页
* @param pagesize
* @param ordername
* 为null或length为0则不排序
* @param asc
* @return
* @author 华理德
* @date 2009-09-23
*/
protected List<T> getListByIn(final String name,final Collection values,final boolean[] asc) {
if(values == null || values.isEmpty()) return new ArrayList();
return getHibernateTemplate().executeFind(new HibernateCallback() {
public Object doInHibernate(Session session) throws HibernateException,sqlException {
Criteria c = session.createCriteria(getBean());
c.add(Restrictions.in(name,values));
if(currypage > 0) {
c.setFirstResult((currypage - 1) * pagesize);
c.setMaxResults(pagesize);
}
if(ordername != null && ordername.length>0) {
for(int i = 0; i < ordername.length; i++) {
boolean flag = asc[i];
if(flag) c.addOrder(Order.asc(ordername[i]));
else c.addOrder(Order.desc(ordername[i]));
}
}
return c.list();
}
});
}

/**
* 根据条件查找记录的总数
* @param param
* @param value
* @return
*/
public int getBeanCountByIn(final String param,final Collection value){
if(value ==null || value.isEmpty()){return 0;}
return (Integer)getHibernateTemplate().execute(new HibernateCallback() {

public Object doInHibernate(Session sess)
throws HibernateException,sqlException {
Criteria c = sess.createCriteria(getBean());
c.add(Restrictions.in(param,value));
return c.setProjection(Projections.rowCount()).uniqueResult();
}
});
}

/**
* 根据条件查找记录
* @param param
* @param value
* @return
*/
public List<T> getBeanListByIn(String param,Collection value){
return getListByIn(param,value,null);
}

/**
* 根据条件查找记录并分页
* @param param
* @param value
* @param cpage
* @param pagesize
* @return
*/
public List<T> getBeanListByIn(String param,int pagesize){
return getListByIn(param,cpage,"sid",false);
}

/**
* 根据条件查找记录并按照条件排序
* @param param
* @param value
* @param cpage
* @param pagesize
* @param Order
* @param asc
* @return
*/
public List<T> getBeanListByIn(String param,boolean asc){
return getListByIn(param,asc);
}

/*
* =======================================================================
* 提供给本类处理的私有方法
* =======================================================================
*/
/**
* 根据条件返回Map
*
* @param name
* @param value
* @return name为null或""则返回null
*/
private Map<String,Object> getMap(String name,Object value) {
if(name != null && !name.equals("")) {
Map<String,Object> hs = new HashMap<String,Object>();
hs.put(name,value);
return hs;
}
return null;
}
}

web.xml的配置

<context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:application-*.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> 扫描xml配置文件 </listener> <servlet> <servlet-name>spring</servlet-name> <servlet-class>org.springframework.web.servlet.dispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:spring-servlet.xml</param-value> </init-param> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>spring</servlet-name> <url-pattern>/*</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>default</servlet-name> <url-pattern>/static/*</url-pattern> </servlet-mapping> <servlet> <servlet-name>dwr</servlet-name> <servlet-class>org.directwebremoting.spring.DwrSpringServlet</servlet-class> <init-param> <param-name>debug</param-name> <param-value>true</param-value> </init-param> <init-param> <param-name>crossDomainSessionSecurity</param-name> <param-value>false</param-value> </init-param> <init-param> <param-name>allowScriptTagRemoting</param-name> <param-value>true</param-value> </init-param> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dwr</servlet-name> <url-pattern>/dwr/*</url-pattern> </servlet-mapping> <servlet> <servlet-name>freemarker</servlet-name> <servlet-class>org.springframework.web.servlet.dispatcherServlet</servlet-class> <init-param> <param-name>contextConfigLocation</param-name> <param-value>classpath:ftl-servlet.xml</param-value> </init-param> <load-on-startup>0</load-on-startup> </servlet> <servlet-mapping> <servlet-name>freemarker</servlet-name> <url-pattern>/ftl/*</url-pattern> </servlet-mapping> <servlet> <servlet-name>error</servlet-name> <servlet-class>com.guu.uurms.servlet.ErrorServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>error</servlet-name> <url-pattern>/error</url-pattern> </servlet-mapping> <filter> <filter-name>ftl</filter-name> <filter-class>com.guu.uurms.filter.FreemarkerFilter</filter-class> </filter> <filter-mapping> <filter-name>ftl</filter-name> <url-pattern>*.ftl</url-pattern> </filter-mapping> <filter> <filter-name>controller</filter-name> <filter-class>com.guu.uurms.filter.ControllerFilter</filter-class> </filter> <filter-mapping> <filter-name>controller</filter-name> <url-pattern>/*</url-pattern> </filter-mapping> <error-page> <error-code>404</error-code> <location>/error</location> </error-page> <error-page> <error-code>500</error-code> <location>/error</location> </error-page> <welcome-file-list> <welcome-file>index.ftl</welcome-file> </welcome-file-list> </web-app>

freemaker+dwr+springmvc的配置的更多相关文章

HTML5 WebSocket实现点对点聊天的示例代码

这篇文章主要介绍了HTML5 WebSocket实现点对点聊天的示例代码的相关资料,小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
ios – 在Swift的UIView中找到UILabel

我正在尝试在我的UIViewControllers的超级视图中找到我的UILabels.这是我的代码：这是在Objective-C中推荐的方式,但是在Swift中我只得到UIViews和CALayer.我肯定在提供给这个方法的视图中有UILabel.我错过了什么？我的UIViewController中的调用：解决方法使用函数式编程概念可以更轻松地实现这一目标.
ios – 在Swift中将输入字段字符串转换为Int

所以我非常擅长制作APP广告Swift,我试图在文本字段中做一些非常简单的输入,取值,然后将它们用作Int进行某些计算.但是’vardistance’有些东西不正确它是导致错误的最后一行代码.它说致命错误：无法解开Optional.None解决方法在你的例子中,距离是一个Int？否则称为可选的Int..toInt()返回Int？因为从String到Int的转换可能失败.请参阅以下示例：
如何在iOS中检测文本(字符串)语言？

例如,给定以下字符串：我想检测每个声明的字符串中使用的语言.让我们假设已实现函数的签名是：如果没有检测到语言,则返回可选字符串.因此,适当的结果将是：有一个简单的方法来实现它吗？
xamarin – 崩溃在AccountStore.Create().保存(e.Account,“);

在Xamarin.Forms示例TodoAwsAuth中https://developer.xamarin.com/guides/xamarin-forms/web-services/authentication/oauth/成功登录后,在aOnAuthenticationCompleted事件中,应用程序在尝试保存到Xamarin.Auth时崩溃错误说不能对钥匙串说期待着寻求帮助.解决方法看看你
ios – 将视频分享到Facebook

我正在编写一个简单的测试应用程序,用于将视频从iOS上传到Facebook.由于FacebookSDK的所有文档都在Objective-C中,因此我发现很难在线找到有关如何使用Swift执行此操作的示例/教程.到目前为止我有这个在我的UI上放置一个共享按钮,但它看起来已禁用,从我读到的这是因为没有内容设置,但我看不出这是怎么可能的.我的getVideoURL()函数返回一个NSURL,它肯定包含视
xcode – 错误“线程1：断点2.1”

我正在研究RESTAPI管理器.这是一个错误,我无法解决它.我得到的错误在下面突出显示.当我打电话给这个班级获取资源时：我评论的线打印：Thread1:breakpoint2.1我需要修复错误的建议.任何建议都非常感谢解决方法您可能在不注意的情况下意外设置了断点.单击并拖动代表断路器外部断点的蓝色刻度线以将其擦除.
ios – 更改导航栏标题swift中的字符间距

类型的值有人可以帮我这个或建议一种不同的方式来改变swift中导航栏标题中的字符间距吗？解决方法您无法直接设置属性字符串.你可以通过替换titleView来做一个技巧
ios – 如何从变量访问属性或方法？

是否可以使用变量作为Swift中方法或属性的名称来访问方法或属性？在PHP中,您可以使用$object->{$variable}.例如编辑：这是我正在使用的实际代码：解决方法你可以做到,但不能使用“纯粹的”Swift.Swift的重点是防止这种危险的动态属性访问.你必须使用Cocoa的Key-ValueCoding功能：非常方便,它完全穿过你要穿过的字符串到属性名称的桥,但要注意：这里是龙.
ios – 如果我将自动释放的对象桥接到Core Foundation,我必须使用__bridge或__bridge_retained吗？

ARC迁移工具遇到了这个问题：特别是,它不确定它是否应该执行__bridge或__bridge_retained.而我也是.-fileURLWithPath返回一个自动释放的对象,在这个地方我不是fileURL的所有者.但与此同时,该对象的保留计数至少为1.我敢打赌,这只能用__bridge来完成.解决方法您只想为此使用常规__bridge强制转换.仅当您想要管理强制转换CF对象的生命周期时,才会使用__bridge_retained.例如：所以__bridge_retained确实告诉编译器你有一个AR

随机推荐

Ajax+SpringMVC requestBody

ajax+SpringMVC经验证,上文写的是比较正确的,所以转过来保存一下.传JSON对象前端后端传JSON字符串+@RequestBody接收前端后端
Ajax异步提交List对象，SpringMvc如何接收？

Springmvc的一个问题一直被广大开发者所诟病，就是在list对象的转换上一直并不是特别好用，网上很多解决方法关于不同的表单提交方式这里就不多说了，只介绍下ajax方式提交list对象的方法。比如你要通过ajax传递下面一段数据到controller：如果像下面这样写肯定是无法传递到后端的：这样肯定会报错User找不到之类的，那么怎么解决呢？
H5FormData+AJAX+SpringMVC跨域异步上传文件

最近都没时间整理资料了，一入职就要弄懂业务，整天被业务弄得血崩。总结下今天弄了一个早上的跨域异步上传文件。主要用到技术有HTML5的FormData，AJAX，SpringMVC。注意这个upload.js是自己写的，里面那个ajaxFileUpload并不是jQuery提供的那个上传插件的方法。服务端接口写法：@ResponseBody@RequestMappingpublicvoidaddPicthrowsIOException{System.out.println;response.getWrite
ajax与springmvc传参方式总结

若传递的是数组对象，需要用第二种方式，否则失败。①前台$.ajax;后台：@RequestMapping@ResponseBodypublicStringdel{return"";}如果不加Traditional,通过观察浏览器中发送的请求，可以发现参数如下：newArray[]:delArray[]:可以看到，参数的名字为newArray[]而不是我们所定义的newArray，也就是说，当传递数组时，会在我们的数组名称后自动加上”[]”，所以后台接不到。
AJAX和SpringMVC交互

AJAX利用jquerySPRING
ajax json异步springmvc http请求返回状态码为406的解决

是因为缺少json相关jar包，网上很多人只是给出了前两个jar，其实不全，依旧406，应该给出四个
ajax传递json参数到springmvc

前后端交互,经常出现400或者415,这里写个小笔记,已做参考,不断完善方式一:前台代码:后台代码:
AJAX+SpringMVC 获取后台数据的方式

利用ajax同步获取服务器的数据，当页面加载完成的时候后台代码：Service层：List转json方法：学习中。。。。。。
AJAX+JQuery+SpringMVC实现图片上传

利用ajax实现前端与后台的交互，从服务端获取数据，并调回到前端进行解析。下面是前端代码：下面上后端的代码：Controller层Service层：DAO层：以上都是获取数据的部分，下面是提交数据的代码：Controller：Service：这个是文件上传的关键部分以上
$.ajax与SpringMVC的那点事-传参与返回

由于有@RresponseBody标示，SpringMVC会将头信息中的Content-Type:application/x-www-form-urlencoded（默认值）改为application/json;，即返回为JSON格式，所以ajax的dataType:"json"可有可无。