基于hibernate的基本dao接口与实现 及 sql模糊查询特殊字符处理 及 struts 特殊字符在界面正常回显

最新推荐文章于 2022-08-11 15:56:56 发布
最新推荐文章于 2022-08-11 15:56:56 发布
阅读量1.4k 收藏
点赞数
分类专栏： hibernate hql 文章标签： Hibernate hql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/happyzwh/article/details/8904063
版权

接口

package com.cslc.pcbp.bms.basic.dao;

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

import org.hibernate.criterion.DetachedCriteria;


/**
 * <P>Title: pcbp_bms</P>
 * <P>Description: 基本DAO接口</P>
 * <P>Copyright: Copyright(c) 2013</P>
 * <P>Company: cslc.com.cn</P>
 * @author zwh
 * @version 1.0
 * @date Apr 12, 2013
 *
 */
public interface IBaseDao<T> {
 
 /**
  *  持久化实体
  *  @param t 实体对象
  * 
  **/
 public void persist(T t) throws Exception;
 
 /**
  *  持久化实体
  *  @param t 实体对象
  *  @return Long 持久对象主键值
  **/
 public Long save(T t) throws Exception;

 /**
  *  查找
  *  @param id 实体对象id
  *  @return T 持久对象
  **/
    public T findById(Serializable  id) throws Exception;

    /**
  *  更新
  *  @param t 实体对象
  *  @return T 持久对象
  **/
    public T update(T t) throws Exception;
   
    /**
  *  批量更新  使用 名称参数占位  即  xxx = :ttt 类型  不使用  xxx = ?
  *  @param hql 更新语句
  *  @param paraNameArr 占位参数名
  *  @param paraValueArr 参数值
  *  @param paraTypeArr 参数类型
  *  @return Integer 批量更新影响行数
  **/
    public Integer batchUpdate(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList) throws Exception;
   
    /**
  *  更新
  *  @param t 实体对象
  *  @return T 持久对象
  **/
    public void updateNoReturn(T t) throws Exception;

    /**
  *  删除
  *  @param t 实体对象
  * 
  **/
    public void delete(T t) throws Exception;
   
    /**
  *  根据查询对象得实体列表
  *  @param criteria 实体查询对象
  *  @return List<T> 实体对象列表
  **/
 public List<T> findByCriteria(DetachedCriteria criteria) throws Exception;
 
 /**
  *  根据查询对象得对象数量
  *  @param criteria 实体查询对象
  *  @return Integer 实体对象数量
  **/
 public Integer findCountByCriteria(final DetachedCriteria criteria) throws Exception;
 
  /**
  *  根据查询对象得实体分页列表
  *  @param criteria 实体查询对象
  *  @param pageIndex 页号
  *  @param pageSize  列表长度
  *  @return List<T> 实体对象列表
  **/
 public List<T> findPageByCriteria(final DetachedCriteria criteria,final Integer pageIndex,final Integer pageSize) throws Exception;
   
  /**
  *  根据hql语句得实体数量  要求以 select count(x) 开头  且 使用 名称参数占位  即  xxx = :ttt 类型  不使用  xxx = ?
  *  @param hql hql语句
  *  @param paraNameArr 占位参数名
  *  @param paraValueArr 参数值
  *  @param paraTypeArr 参数类型
  *  @return List<T> 实体对象列表
  **/
 public Integer queryCount(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList) throws Exception;
 
  /**
  *  根据hql语句得实体分页列表  使用 名称参数占位  即  xxx = :ttt 类型  不使用  xxx = ?
  *  @param hql hql语句
     *  @param paraNameArr 占位参数名
  *  @param paraValueArr 参数值
  *  @param paraTypeArr 参数类型
  *  @param pageIndex 页号
  *  @param pageSize  列表长度
  *  @return List<T> 实体对象列表
  **/
 public List<T> queryForPage(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList,final Integer pageIndex,final Integer pageSize) throws Exception;
 
  /**
  *  根据hql语句得实体分页列表
  *  @param hql hql语句
  *  @param pageIndex 页号
  *  @param pageSize  列表长度
  *  @return List<T> 实体对象列表
  **/
 public List<T> queryForPage(final String hql,final Integer pageIndex,final Integer pageSize) throws Exception;
 /**
  * 查询所有记录数(HQL)
  *
  * @param hql 查询的语句
  * @return 总记录数
  */
 public Integer getAllRowCount(final String hql);
 /**
  *  根据hql语句得实体分页列表
  *  @param hql hql语句
  *  @param pageIndex 页号
  *  @param pageSize  列表长度
  *  @return List<T> 实体对象列表
  **/
 public List<T> queryForPageSQL(final String sql,final Integer pageIndex,final Integer pageSize) throws Exception;
 /**
  * 查询所有记录数(HQL)
  *
  * @param hql 查询的语句
  * @return 总记录数
  */
 public Integer getAllRowCountSQL(final String sql);  

}
实现

package com.cslc.pcbp.bms.basic.dao.impl;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.SQLException;
import java.util.Collection;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.springframework.orm.hibernate3.HibernateCallback;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;

import com.cslc.pcbp.bms.basic.dao.IBaseDao;

/**
 * <P>Title: pcbp_bms</P>
 * <P>Description: 基本DAO接口实现</P>
 * <P>Copyright: Copyright(c) 2013</P>
 * <P>Company: cslc.com.cn</P>
 * @author zwh
 * @version 1.0
 * @date Apr 12, 2013
 *
 */
public class BaseDaoImpl<T> extends HibernateDaoSupport implements IBaseDao<T>{

 @SuppressWarnings("unchecked")
 public BaseDaoImpl() {
   Type type = this.getClass().getGenericSuperclass();
   if (type instanceof ParameterizedType) {
    Type trueType = ((ParameterizedType)type).getActualTypeArguments()[0]; 
    this.type = (Class<T>) trueType;
   }
 }
 
 private Class<T> type;
 
 public BaseDaoImpl(Class<T> type){
  this.type = type;
 }

 @Override
 public void delete(T t) throws Exception {
  // TODO Auto-generated method stub
  this.getHibernateTemplate().delete(t);
 }

 @SuppressWarnings("unchecked")
 @Override
 public List<T> findByCriteria(DetachedCriteria criteria) throws Exception {
  // TODO Auto-generated method stub
  return (List<T>)this.getHibernateTemplate().findByCriteria(criteria);
 }

 @SuppressWarnings("unchecked")
 @Override
 public T findById(Serializable id) throws Exception {
  // TODO Auto-generated method stub
  return (T)this.getHibernateTemplate().get(type, id);
 }

 @SuppressWarnings("unchecked")
 @Override
 public List<T> findPageByCriteria(final DetachedCriteria detachedCriteria,
   final Integer pageIndex, final Integer pageSize) throws Exception {
  // TODO Auto-generated method stub
  return (List<T>)getHibernateTemplate().execute(new HibernateCallback() {
     public Object doInHibernate(Session session) throws HibernateException,SQLException { 
                  Criteria criteria = detachedCriteria.getExecutableCriteria(session); 
                  if(pageIndex != null && pageSize != null){
                   criteria.setFirstResult((pageIndex-1)*pageSize).setMaxResults(pageSize);
                  }
                  return criteria.list();   
              } 
          });
 }

 @Override
 public void persist(T t) throws Exception {
  // TODO Auto-generated method stub
  this.getHibernateTemplate().persist(t);
 }

 @Override
 public Long save(T t) throws Exception {
  // TODO Auto-generated method stub
  return (Long)getHibernateTemplate().save(t);
 }

 @SuppressWarnings("unchecked")
 @Override
 public T update(T t) throws Exception {
  // TODO Auto-generated method stub
  return (T)this.getHibernateTemplate().merge(t);
 }
 
 @Override
 public void updateNoReturn(T t) throws Exception{
  this.getHibernateTemplate().update(t);
 }

 @SuppressWarnings("unchecked")
 @Override
 public Integer findCountByCriteria(final DetachedCriteria detachedCriteria)
   throws Exception {
  // TODO Auto-generated method stub
  return (Integer)getHibernateTemplate().execute(new HibernateCallback() {
   public Object doInHibernate(Session session) throws HibernateException,SQLException { 
                Criteria criteria = detachedCriteria.getExecutableCriteria(session); 
                return ((Integer)criteria.setProjection(Projections.rowCount()).uniqueResult()).intValue();
            } 
        });
 }

 @SuppressWarnings("unchecked")
 @Override

 public List<T> queryForPage(final String hql,final Integer pageIndex,final Integer pageSize)
   throws Exception {
  // TODO Auto-generated method stub
  return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){
    public Object doInHibernate(Session session) throws HibernateException,SQLException{
     Query query = session.createQuery(hql);
     if(pageIndex != null && pageSize != null){
      query.setFirstResult((pageIndex-1)*pageSize);
      query.setMaxResults(pageSize);
     }
     return query.list();
    }
   });
 }
 @SuppressWarnings("unchecked")
 @Override
 public Integer queryCount(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList) throws Exception {
  // TODO Auto-generated method stub
  return (Integer)getHibernateTemplate().execute(new HibernateCallback(){
   public Object doInHibernate(Session session) throws HibernateException,SQLException{
    Query query = session.createQuery(hql);
    if(paraNameList != null && paraNameList.size() > 0){    
     for(int i = 0;i<paraNameList.size();i++){
      if(paraValueList.get(i) instanceof Collection){
       query.setParameterList(paraNameList.get(i), (Collection)paraValueList.get(i), paraTypeList.get(i));
      }else{
       query.setParameter(paraNameList.get(i), paraValueList.get(i), paraTypeList.get(i));
      }
     }
    }
    return ((Long)query.uniqueResult()).intValue();
   }
  });
 }

 @SuppressWarnings("unchecked")
 @Override
 public List<T> queryForPage(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList
    ,final Integer pageIndex,final Integer pageSize) throws Exception {
  // TODO Auto-generated method stub
  return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){
   public Object doInHibernate(Session session) throws HibernateException,SQLException{
    Query query = session.createQuery(hql);
    if(paraNameList != null && paraNameList.size() > 0){    
     for(int i = 0;i<paraNameList.size();i++){
      if(paraValueList.get(i) instanceof Collection){
       query.setParameterList(paraNameList.get(i), (Collection)paraValueList.get(i), paraTypeList.get(i));
      }else{
       query.setParameter(paraNameList.get(i), paraValueList.get(i), paraTypeList.get(i));
      }
     }
    }
    if(pageIndex != null && pageSize != null){
     query.setFirstResult((pageIndex-1)*pageSize);
     query.setMaxResults(pageSize);
    }
    return query.list();
   }
  });
 }

 @SuppressWarnings("unchecked")
 @Override
 public Integer getAllRowCount(final String hql) {
  List list  = getHibernateTemplate().executeFind(new HibernateCallback() {
          public Object doInHibernate(Session session)
              throws HibernateException, SQLException {
              Query query = session.createQuery(hql);
              List result = query.list();
              return result;
          }
      });
  
  if(list != null && list.size() > 0) {
   return (Integer)(list.size());
  }
  return 0;
 }

 @SuppressWarnings("unchecked")
 @Override
 public Integer getAllRowCountSQL(final String sql) {
  List list  = getHibernateTemplate().executeFind(new HibernateCallback() {
          public Object doInHibernate(Session session)
              throws HibernateException, SQLException {
              Query query = session.createSQLQuery(sql);
              List result = query.list();
              return result;
          }
      });
  
  if(list != null && list.size() > 0) {
   return (Integer)(list.size());
  }
  return 0;
 }

 @SuppressWarnings("unchecked")
 @Override
 public List<T> queryForPageSQL(final String sql, final Integer pageIndex,
   final Integer pageSize) throws Exception {
  // TODO Auto-generated method stub
  return (List<T>)getHibernateTemplate().execute(new HibernateCallback(){
    public Object doInHibernate(Session session) throws HibernateException,SQLException{
     Query query = session.createSQLQuery(sql);
     if(pageIndex != null && pageSize != null){
      query.setFirstResult((pageIndex-1)*pageSize);
      query.setMaxResults(pageSize);
     }
     return query.list();
    }
   });
 }

 @SuppressWarnings("unchecked")
 @Override
  public Integer batchUpdate(final String hql,final List<String> paraNameList,final List<Object> paraValueList,final List<org.hibernate.type.Type> paraTypeList) throws Exception {
  // TODO Auto-generated method stub
   return (Integer)getHibernateTemplate().execute(new HibernateCallback(){
    public Object doInHibernate(Session session) throws HibernateException,SQLException{
     Query query = session.createQuery(hql);
     if(paraNameList != null && paraNameList.size() > 0){    
      for(int i = 0;i<paraNameList.size();i++){
       if(paraValueList.get(i) instanceof Collection){
        query.setParameterList(paraNameList.get(i), (Collection)paraValueList.get(i), paraTypeList.get(i));
       }else{
        query.setParameter(paraNameList.get(i), paraValueList.get(i), paraTypeList.get(i));
       }
      }
     }
     return query.executeUpdate();
    }
   });
 }
}

例子:

子接口:

package com.cslc.pcbp.bms.system.dao;

import java.util.List;

import com.cslc.pcbp.bet.entity.bst.TBusiRole;
import com.cslc.pcbp.bms.basic.dao.IBaseDao;

/**
 * <P>Title: pcbp_bms</P>
 * <P>Description: 业务角色DAO接口</P>
 * <P>Copyright: Copyright(c) 2013</P>
 * <P>Company: cslc.com.cn</P>
 * @author zwh
 * @version 1.0
 * @date May 2, 2013
 *
 */
public interface IRoleDao  extends IBaseDao<TBusiRole>{
 
 /**
  *  查询角色个数 模糊查询 %*%
  *  @param name 角色名称
  *  @return Integer 角色个数
  **/
 public Integer getRoleCount(String name) throws Exception;
 
 /**
  *  查询角色列表 模糊查询 %*%
  *  @param name 角色名称
  *  @return  List<TBusiRole> 角色列表
  **/
 public List<TBusiRole> getRoleList(String name,Integer pageIndex,Integer pageSize) throws Exception;

}

子接口实现:

package com.cslc.pcbp.bms.system.dao.impl;

import java.util.ArrayList;
import java.util.List;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Hibernate;

import com.cslc.pcbp.bet.entity.bst.TBusiRole;
import com.cslc.pcbp.bms.basic.dao.impl.BaseDaoImpl;
import com.cslc.pcbp.bms.system.dao.IRoleDao;
import com.cslc.pcbp.bms.tools.CharConversion;

public class RoleDaoImpl extends BaseDaoImpl<TBusiRole> implements IRoleDao{

 @Override
 public Integer getRoleCount(String name) throws Exception {
  // TODO Auto-generated method stub
//  DetachedCriteria criteria = DetachedCriteria.forClass(TBusiRole.class);
//  if(StringUtils.isNotBlank(name)){
//   criteria.add(Restrictions.like("name", name,MatchMode.ANYWHERE));
//  }
//  return this.findCountByCriteria(criteria);
  
  StringBuilder hql = new StringBuilder("select count(t) from TBusiRole t ");
  List<String> paraNameList = new ArrayList<String>();
  List<Object> paraValueList = new ArrayList<Object>();
  List<org.hibernate.type.Type> paraTypeList = new ArrayList<org.hibernate.type.Type>();
  
  if(StringUtils.isNotBlank(name)){
             hql.append(" where t.name like :name escape '\\'");
             paraNameList.add("name");
             paraValueList.add("%"+CharConversion.sqlSpecialCharConversion(name)+"%");
             paraTypeList.add(Hibernate.STRING);
  }
  
  return this.queryCount(hql.toString(), paraNameList, paraValueList, paraTypeList);
 }

 @Override
 public List<TBusiRole> getRoleList(String name, Integer pageIndex,
   Integer pageSize) throws Exception {
  // TODO Auto-generated method stub
//  DetachedCriteria criteria = DetachedCriteria.forClass(TBusiRole.class);
//  if(StringUtils.isNotBlank(name)){
//   criteria.add(Restrictions.like("name", name,MatchMode.ANYWHERE));
//  }
//  criteria.addOrder(Order.desc("createdTime")).addOrder(Order.desc("roleId"));
//  return this.findPageByCriteria(criteria, pageIndex, pageSize);
  
  StringBuilder hql = new StringBuilder(" from TBusiRole t");
  List<String> paraNameList = new ArrayList<String>();
  List<Object> paraValueList = new ArrayList<Object>();
  List<org.hibernate.type.Type> paraTypeList = new ArrayList<org.hibernate.type.Type>();
  
  if(StringUtils.isNotBlank(name)){
             hql.append(" where t.name like :name escape '\\'");
             paraNameList.add("name");
             paraValueList.add("%"+CharConversion.sqlSpecialCharConversion(name)+"%");
             paraTypeList.add(Hibernate.STRING);
  }
  
  return this.queryForPage(hql.toString(), paraNameList, paraValueList, paraTypeList,pageIndex,pageSize);
 }

}

模糊查询时特殊字符转换:

package com.cslc.pcbp.bms.tools;

import org.apache.commons.lang.StringUtils;

public class CharConversion {
 
 public static String sqlSpecialCharConversion(String parameter){
  if(StringUtils.isBlank(parameter))return "";
  return parameter.replaceAll("\\\\", "\\\\\\\\").replaceAll("'", "\'").replaceAll("%", "\\\\%").replaceAll("_", "\\\\_").replaceAll("]", "]]");
 }
}

注意几点:

1. 处理模糊查询时需要对特殊字符进行转换;

2. 模糊查询对特殊字符进行处理后sql语句需加入escape '\\'，且放在紧跟where语句后其他语句前，如果有多个模糊查询  可用 if(hql.indexOf("like") != -1)hql.append(" escape '\\' "); 来加入

3. DetachedCriteria与Criteria在进行非模糊查询时已对特殊字符进行转换.

 

4. struts 显示标签 如下可以正常显示特殊字符

   即:值外双引号 内单引号

     <input type="text" name="roleName" value="<s:property value='roleName' />"/>

 

 

happyzwh
关注
专栏目录
[Java 面试]-- 常见问题及答案
欢迎来到我的博客，一起探索代码里的世界！
08-09 2864
---------------------------corejava---------------------------------------- 1.列出8种基本数据类型和其对应的包装类。（1分） 答： （1）整型     byte short、int、float、long、double （2）字符型    char （3）布尔类型 boolean 对应包装类：Byte Shor...
搭建SSM框架并实现增删查改功能
qq_43700270的博客
03-29 2204
搭建SSM框架并实现增删查改功前言一、概述二、搭建一个SSM的过程三、配置相关文件四、在Java下创建测试类五、在webapp下创建html页面 要一直做勤快的人，加油 前言 使用eclipse+tomcat7+mysq+maven实现SSM框架下的增删查改功能，把自己的知识整理一下，方便以后查阅。 一、概述 SSM框架在项目开发中经常使用到，相比于SSH框架，它在近几年的开发中运用的更加广泛...
通用分页完整版及通用模糊查询
m0_46699799的博客
06-05 350
通用分页+模糊查询最后效果概念及目的大概步骤具体代码实现总结 最后效果 （这个颜色别吐槽，吐槽就是你对） 概念及目的 目的： 基于bootatrap，考虑到通用的问题完成书籍的分页，查询。 概念： 举个例子—— 一个玩具表要做分页查询需要连接数据库-写sql语句-获取执行对象-得到结果集-返回结果集； 而一个书籍表要做分页查询也是差不多的步骤只不过sql语句不一样，返回的类型不一样，和获得结果集时不一样罢了。 那么分页的概念就是将每个表分页时都具有的共性代码写一个BaseDao完成所有的类似的查询需求。
Hibernate_根据条件动态组装sql/hql语句(仿ibatis动态查询语句功能)
ALL TECHNOLOGIES ARE CLOUDS
06-28 482
via: http://blog.csdn.net/crazycoder2010/article/details/7414152   1.功能需求背景  项目中使用hibernate作为数据持久层框架，主要考虑hibernate在进行一些简单的crud操作时非常便利，不需要和ibatis似的为每个sql操作都写一堆文件，但是同时也带来了一些局限性，如类似ibatis强大的动态查询功能用不了了...
Hibernate模糊查询
qq_44884269的博客
04-15 213
Hibernate模糊查询
SQL语句在DAO中实现动态模糊查找
xiantingxinbuone的专栏
08-10 1507
方法一： public List queryByMul(String  no, String name)  { String hql="from Stuent as n where n.no like ? or n.name like ?"; //String[] s={"%"+你要放的值+"%","%"+你要放的值+"%"}; String[] s={"%"+no+"%",
Hibernate HQL基础 使用SQLQuery对象实现动态表映射
weixin_33991727的博客
10-10 202
在实际项目的开发中，有时需要操作动态表的数据。假设当前所开发的系统需要通过数据库记录系统的日志信息，由于日志信息数据量庞大，所以为了高效了记录和查询，每个月动态产生一个保存日志的信息表，表名包含表示年月的字符串。例如,2009年2月的日志信息保存在log200902这个表中，log200903表示2009年3月的日志信息数据。以此类推，这些表均用于保存日志数据，其中表中的字段...
JAVAWEB开发之SpringMVC详解(二)——高级开发、数据回显、参数绑定集合、图片上传、json交互、validation校验、异常处理、RESTful支持、拦截器
06-25 4205
知识回顾 springmvc框架 用户请求url到DispatcherServlet前端控制器，相当于中央调度器，降低系统各组件之间的耦合度。 DispatcherServlet前端控制器通过HandlerMapping处理器映射器根据url找到Handler。 DispatcherServlet前端控制器通过HandlerAdapter处理器适配器执行Handler。 Dispatch
struts2、hibernate、spring
yu_xiao_jian的博客
06-26 381
struts  1. struts2配置文件是(struts.xml) 2. struts2核心控制器是(FilterDispatcher) 3. struts2配置文件中Action标签的class属性值是(action类的全名) name属性的值是(代表Action的名称 从前台访问时的路径) 4. struts2配置文件中result标签的属性值 默认是(d
Java基础
super_的博客
02-16 464
SSH: Spring：负责业务层管理（控制了所有的Action对象和业务逻辑类的生命周期）。分为：IOC控制反转 [控制权由应用代码中转到了外部容器] 和依赖注入 [由容器动态的将某种依赖关系注入到组件中] 、AOP事务的处理)； Struts：主要是控制的作用，核心是controller，即ActionServlet，ActionServlet的核心是struts-config.xml，主要
mybatis 增删改查 模糊查询 操作
10-18
mybatis 增删改查 模糊查询 操作
Hibernate动态更新HQL实现
iteye_17179的博客
04-30 326
[size=medium][code="java"]/** * 动态更新 * * @param t * 更新对象 * @param keyName * 主键名称 * @param annotationClass * 更新对象中的属性为自定...
一个DAO 一个Interface 搞定spring ＋ hibernate＋动态hql查询
sun_cat的专栏
03-14 275
找了一些spring的文章看了下，有所启发，于是大概的总结了下，希望大家多提提意见 为了实现自己程序对spring和hibernate的过分依赖，因此自己写了一个接口，封装了8个常用的数据库操作 接口如下 java 代码 package com.pig.dao;       import java.io.Serializable;    import j...
mybatis接口式的模糊查询、分页、增删改、事务处理
star180的专栏
08-09 1042
这次我们把上次的改为接口式的
基于hibernate的泛型dao实现
tonysong111073的专栏
02-03 204
我们在进行hibernate开发时，因为hibernate是基于对象的ORM，所以由此我们可以在hibernate的基础上在做一层封装，从而大大简化我们的DAO层代码。 首先封装一个分页工具类：Pager<T> public class Pager<T> { private int offset; private int pagesize; private L...
hql小知识
Sun
04-18 633
一.回顾基本的SQL查询    select/update/delect ... from ... where ...group by... having ...order by... asc/desc    insert into ... value ...    update ... set ...    1.单表查询 select * from xx;    2.多表查询 A a1
Hibernate 动态条件查询
永远相信美好的事情即将发生
03-03 2099
Hibernate 条件动态查询 Hibernate 是一个开放源代码的对象关系映射框架,它对JDBC进行了非常轻量级的对象封装。提供了高效的程序与数据库之间的交互接口。从产品特性上看，Hibernate 是一个全自动的 orm 框架，这意味着无须用户再手动编写 SQL 语句，只需要通过 Hibernate 就可以自动生成 SQL 语句。这从使用的角度上来看是非常方便的。除此之外，Hibernate 还做到了对数据库层的抽象，使得程序能够做到在切换数据库（如从 Oracle 切换到 MySQL ）时完全无感
关于处理SQL特殊字符的基本方法总结
热门推荐
05-22 3万+
1、sql特殊字符带来的问题 在sql语句中，有些特殊字符，是sql保留的。比如 ' [ ]  等。我们可以先看看它们的用法。 当需要查询某数据时，加入条件语句，或着当你需要insert记录时，我们用  '  来将字符类型的数据引起来。比如： Select * from Customers where City = 'London' 当表的名字或列的名字中，含有空格等一些特殊字符时
sql注入漏洞
qz362228的博客
08-11 2611
sql注入漏洞原理，类型，防御方式，绕过技巧
批处理常用特殊符号详解与实例
7. **其他特殊标记符**：包括CR（命令行结束符）、Escape（ANSI转义字符引导符）、Space（参数界定符）等，这些符号虽然不是常用，但在特定场景下也起到重要作用。 8. **行内注释**：使用百分号 `%` 结合内容作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值