程序博客网 > mac读取不了移动硬盘

仅一行代码完成各种数据库操作，基于spring的HibernateTemplate

来源：互联网 发布：mac读取不了移动硬盘 编辑：程序博客网 时间：2024/06/07 03:31

1. [代码][Java]代码

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
 
import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Property;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.HibernateTemplate;
 
public class BaseHibernate {
    private static HibernateTemplate hibernateTemplate;
 
    @SuppressWarnings("static-access")
    public void setHibernateTemplate(HibernateTemplate hibernateTemplate) {
        this.hibernateTemplate = hibernateTemplate;
    }
 
    /**
     * 插入对象
     *
     * @param entity
     * @return
     */
    public int save(Object entity) {
        return (Integer) hibernateTemplate.save(entity);
    }
 
    /**
     * 删除对象
     *
     * @param entity
     */
    public void delete(Object entity) {
        hibernateTemplate.delete(entity);
    }
 
    /**
     * 修改对象
     *
     * @param entity
     */
    public void update(Object entity) {
        hibernateTemplate.update(entity);
    }
 
    /**
     * 根据ID查询对象
     *
     * @param entityClass
     *            类名,如:String.class
     * @param id
     *            ID值
     */
    public <T> T query(Class<T> entityClass, int id) {
        return hibernateTemplate.get(entityClass, id);
    }
 
    /**
     * 查询全部
     *
     * @param className
     *            类名
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> queryAll(Class<?> className) {
        return hibernateTemplate.find("from " + className.getName());
    }
 
    /**
     * 分页
     *
     * @param entityClass
     *            类名
     * @param index
     *            当前页数
     * @param size
     *            每页显示的大小
     * @param order
     *            排序类型
     * @param propertyName
     *            要排序的属性名
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> paging(final Class<?> entityClass, final int index,
            final int size, final Order order, final String... propertyName) {
        List<T> list = hibernateTemplate.executeFind(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(entityClass);
                if (propertyName != null && propertyName.length > 0) {
                    switch (order) {
                    case ASC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .asc(propertyName[0]));
                        break;
                    case DESC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .desc(propertyName[0]));
                        break;
                    }
                }
                criteria.setFirstResult((index - 1) * size);
                criteria.setMaxResults(size);
                return criteria.list();
            }
        });
        return list;
    }
 
    @SuppressWarnings("unchecked")
    public long getSumRecord(final Class<?> className) {
        List<Long> count = new ArrayList<Long>();
        count = hibernateTemplate.find("select COUNT(*) from "
                + className.getName());
        return count.size() > 0 ? (count.get(0)) : 0L;
    }
 
    /**
     * 获取总页数
     *
     * @param className
     *            类名
     * @param size
     *            每页显示的大小
     * @return
     */
    @SuppressWarnings("unchecked")
    public long sumPage(final Class<?> className, int size) {
        List<Long> count = new ArrayList<Long>();
        count = hibernateTemplate.find("select COUNT(*) from "
                + className.getName());
        return count.size() > 0 ? (count.get(0) - 1 + size) / size : 0L;
    }
 
    /**
     * 根据字段查询
     *
     * @param params
     *            字段列表
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> queryByProperty(final Class<?> className,
            final Map<String, Object> params) {
        return hibernateTemplate.executeFind(new HibernateCallback() {
            public List<?> doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                for (String field : params.keySet())
                    criteria.add(Property.forName(field).eq(params.get(field)));
                return criteria.list();
            }
        });
    }
 
    /**
     * 根据字段查询可以分的页数
     *
     * @param className
     *            要查询的实体类
     * @param params
     *            属性列表
     * @param size
     *            每页显示的大小
     * @return
     */
    @SuppressWarnings("unchecked")
    public long queryByPropertyGetSumPage(final Class<?> className,
            final Map<String, Object> params, final int size) {
        List<Integer> object = hibernateTemplate
                .executeFind(new HibernateCallback() {
                    public Object doInHibernate(Session session)
                            throws HibernateException, SQLException {
                        Criteria criteria = session.createCriteria(className);
                        for (String field : params.keySet())
                            criteria.add(Property.forName(field).eq(
                                    params.get(field)));
                        criteria.setProjection(Projections.rowCount());
                        return criteria.list();
                    }
                });
        int count = object == null ? 0 : object.get(0);
        return count > 0 ? (count + size - 1) / size : 0L;
    }
 
    /**
     * 获取总记录数根据属性
     *
     * @param className
     * @param params
     * @param size
     * @return
     */
    @SuppressWarnings("unchecked")
    public long queryByPropertyGetSumRecord(final Class<?> className,
            final Map<String, Object> params) {
        List<Integer> object = hibernateTemplate
                .executeFind(new HibernateCallback() {
                    public Object doInHibernate(Session session)
                            throws HibernateException, SQLException {
                        Criteria criteria = session.createCriteria(className);
                        for (String field : params.keySet())
                            criteria.add(Property.forName(field).eq(
                                    params.get(field)));
                        criteria.setProjection(Projections.rowCount());
                        return criteria.list();
                    }
                });
        return object == null ? 0 : object.get(0);
    }
 
    /**
     * 根据字段查询并分页显示
     *
     * @param className
     *            要分页的实体类
     * @param params
     *            字段列表
     * @param index
     *            当前页
     * @param size
     *            每页显示的大小
     * @param order
     *            排序
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> queryByPropertyPaging(final Class<?> className,
            final Map<String, Object> params, final int index, final int size,
            final Order order, final String... field) {
        return hibernateTemplate.executeFind(new HibernateCallback() {
            public List<?> doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                for (String f : params.keySet())
                    criteria.add(Property.forName(f).eq(params.get(f)));
                if (field != null && field.length != 0) {
                    switch (order) {
                    case ASC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .asc(field[0]));
                        break;
                    case DESC:
                        criteria.addOrder(org.hibernate.criterion.Order
                                .desc(field[0]));
                        break;
                    }
                }
                criteria.setFirstResult((index - 1) * size);
                criteria.setMaxResults(size);
                return criteria.list();
            }
        });
    }
 
    /**
     * 保存或更新对象
     *
     * @param entity
     *            对象
     */
    public void saveOrUpdate(Object entity) {
        hibernateTemplate.saveOrUpdate(entity);
    }
 
    /**
     * 批量修改
     *
     * @param queryString
     *            HQL语句
     * @return 受影响行数
     */
    public int bulkUpdate(String queryString) {
        return hibernateTemplate.bulkUpdate(queryString);
    }
 
    /**
     * 批量修改
     *
     * @param queryString
     *            HQL语句
     * @param values
     *            参数的值
     * @return 受影响行数
     */
    public int bulkUpdate(String queryString, Object... values) {
        return hibernateTemplate.bulkUpdate(queryString, values);
    }
 
    /**
     * 批量删除
     *
     * @param collection
     *            要删除的集合
     */
    public void deleteAll(Collection<?> collection) {
        hibernateTemplate.deleteAll(collection);
    }
 
    /**
     * 模糊查询
     *
     * @param className
     *            类名
     * @param field
     *            字段名
     * @param value
     *            值
     * @param matchMode
     *            匹配模式:ANYWHERE->任意位置、END->结束、START->开始、EXACT->精确匹配
     */
    @SuppressWarnings("unchecked")
    public <T> List<T> Querylike(final Class<?> className, final String field,
            final String value, final MatchMode matchMode) {
        List objects = new ArrayList<Object>();
        objects = hibernateTemplate.executeFind(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Criteria criteria = session.createCriteria(className);
                criteria.add(Property.forName(field).like(value, matchMode));
                return criteria.list();
            }
        });
        return objects;
    }
 
    /**
     * 执行hql查询语句
     *
     * @param hql
     *            hql语句
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public <T> Object executeQuery(final String hql, final Object... values) {
        return hibernateTemplate.execute(new HibernateCallback() {
 
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                return query.list();
            }
        });
    }
 
    /**
     * 查询单个值
     *
     * @param hql
     *            hql语句
     * @param values
     *            参数列表
     * @return 返回单个值
     */
    @SuppressWarnings("unchecked")
    public <T> Object executeSacale(final String hql, final Object... values) {
        return hibernateTemplate.execute(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                query.setMaxResults(1);
                return query.uniqueResult();
            }
        });
    }
 
    /**
     * 执行hql删除、修改语句
     *
     * @param hql
     *            hql语句
     * @param values
     *            值列表
     * @return
     */
    @SuppressWarnings("unchecked")
    public int executNonQuery(final String hql, final Object... values) {
        return hibernateTemplate.execute(new HibernateCallback() {
            public Integer doInHibernate(Session session)
                    throws HibernateException, SQLException {
                Query query = session.createQuery(hql);
                setParams(query, values);
                return query.executeUpdate();
            }
        });
    }
 
    /**
     * 删除表数据
     * @param tableName 表名
     */
     
    @SuppressWarnings("unchecked")
    public void truncate(final String tableName) {
        hibernateTemplate.execute(new HibernateCallback() {
            public Object doInHibernate(Session session)
                    throws HibernateException, SQLException {
                session.createSQLQuery("truncate table " + tableName).executeUpdate();
                return new ArrayList();
            }
        });
 
    }
 
    private void setParams(Query query, Object... values) {
        if (!isEmptyOrNull(values)) {
            for (int i = 0; i < values.length; i++) {
                query.setParameter(i, values[i]);
            }
 
        }
    }
 
    /**
     * 判断值是否为空或
     *
     * @param values
     * @return
     */
    private boolean isEmptyOrNull(Object... values) {
        if (values == null || values.length == 0)
            return true;
        return false;
    }
 
}

2. [代码]排序类型

 
/**
 * 排序类型
 * @author cheng
 *
 */
public enum Order {
    /**
     * 升序排列
     */
    ASC,
    /**
     * 降序排列
     */
    DESC;

3. [代码]实例应用

public interface UsersDao{ 
         /**
     * 根据属性查询
     * @param attrName 属性名
     * @param attrValues 属性值
     * @return Users集合
     */
    public List<Users> queryByProperty(Map<String, Object> propertys);
}
//UserDaoImpl
 
import java.util.List;
import java.util.Map;
 
import org.ps.dao.UsersDao;
import org.ps.entity.Users;
import org.ps.util.BaseHibernate;
import org.ps.util.Order;
 
public class UserDaoImpl extends BaseHibernate implements UsersDao {
 
public List<Users> queryByProperty(Map<String, Object> propertys) {
        return super.queryByProperty(Users.class, propertys);
    }
}
0 0
mac读取不了移动硬盘 mac读取不了移动硬盘
原创粉丝点击
热门IT博客
mac 隐藏硬盘mac 隐藏硬盘
电信网络诈骗的影响电信网络诈骗的影响
淘宝上的订单怎么删除
战天堂阵法进阶数据
linux chroot list
国企算工龄 怎么算法
怎么利用淘宝客买东西
淘宝直通车如何使用
淘宝三哥手机店怎么样
科易数据防泄漏系统
js div 高度
冷光美牙仪的危害 知乎
路灯照度计算软件
淘宝怎么换客服咨询
个人信用基础数据库
java变量命名格式
cd转mp3软件
九阴真经抢号软件
蜘蛛侠淘宝客网站源码
广州买西服知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 百度网盘别人发我一个链接我怎么办 感觉地下和墙壁里有蚂蚁怎么办? 射像头监控摄像头家用卡满了怎么办 微乐贵阳捉鸡麻将不显示头像怎么办 苹果6p用久了卡怎么办 小猪民宿平台限制三天上线怎么办 交易猫买家申请了仲裁我的钱怎么办 雷达石英手表表里面有小灰尘怎么办 电脑宽带用户名和密码忘记了怎么办 腾讯会员不让别人在异地登录怎么办 中毒后电脑文件后缀是lnk怎么办 wps逗号隔的空不一样大怎么办 电脑盘里的文件删不了怎么办 在淘宝买的qq账号被找回了怎么办 微信公众号的密码忘了怎么办 公众号安全助手密码忘了怎么办 微博账号存在发布违规信息怎么办 余额宝转出到银行卡被冻结怎么办 银行账户被冻结被转出钱怎么办 从余额宝转出的资金被冻结怎么办 微信账号卖了但是实名认证了怎么办 uc下载文档里的文档全没了怎么办 二手乐视没有账号和密码怎么办 华为账号密码忘了手机卡丢了怎么办 联想平板微信更新后不可兼容怎么办 小米手机刷完机账号密码忘了怎么办 红米手机的小米账号密码忘了怎么办 小米手机账号密码手机号忘了怎么办 小米手机忘了账号和密码怎么办 自己的小米账号密码忘了怎么办 小米手机丢了不记得小米账号怎么办 小米手环账号密码忘了怎么办 阴阳师一个区的账号找不到了怎么办 阴阳师手机账号代练登录了后怎么办 我的微信账号被盗更改密码了怎么办 vivo手机密保密码忘了怎么办 华为手机保密柜忘记密保问题怎么办 支付宝账号突然说没有了怎么办 快手号密码可能被盗登不上该怎么办 海岛奇兵小米版换手机了怎么办 申诉找回微信密码验证吗错误怎么办

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里