简单HQL语句的面向对象化

最新推荐文章于 2019-04-02 17:13:12 发布
最新推荐文章于 2019-04-02 17:13:12 发布
阅读量5.3w 收藏 5
点赞数 2
文章标签： hql 查询 面向对象 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/km1218/article/details/36627299
版权

在一直使用的HQL查询语句，较多仅是对参数的拼凑。在java面向对象化开发语言，能否将其对象化，以此减少反复性的工作。由于HQL查询语句结构上比较清晰，所以实现上复杂度不高。select ..  from table where ...  groupby row...having...order by... 逐一将查询关键字封装成类，这是小码的开篇博文，技术上有所局限。不足之处，请各位多多指点，不胜感激。


/**
 * 参数抽象类
 * @author kaimin  2014/07/01
 *
 */
public abstract class Parameter {
	
	protected String tableName;//表名
	
	protected String rowName;//行名
	
	public Parameter(String tableName,String rowName){
		this.tableName=tableName;
		this.rowName=rowName;
	}
	
	public abstract String convertSql();

	public String getTableName() {
		return tableName;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	public String getRowName() {
		return rowName;
	}

	public void setRowName(String rowName) {
		this.rowName = rowName;
	}

	

	
}


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

/**
 * 查询排序参数基础类
 * @author kaimin  2014/07/01
 *
 */
public class OrderParameter extends Parameter{
	
	private int sortord=1;//排序方式     1-升序   2-降序
	
	/**
	 * 默认使用升序排序
	 * @param rowName   列名
	 */
	public OrderParameter(String tableName,String rowName) {
		super(tableName,rowName);
		// TODO Auto-generated constructor stub
	}
	
	/**
	 * @param rowName   列名
	 * @param sortord   排序方式     1-升序  2-降序
	 */
	public OrderParameter(String tableName,String rowName,int sortord) {
		super(tableName,rowName);
		this.sortord=sortord;
		// TODO Auto-generated constructor stub
	}	
	
	
	
	@Override
	public String convertSql() {
		// TODO Auto-generated method stub
		StringBuilder sb=new StringBuilder(" ");
		sb.append("order by ");
		sb.append(tableName);
		sb.append(".");
		sb.append(rowName);
		sb.append(" ");
		if(sortord==1)
			sb.append("asc");
		else
			sb.append("desc");
		sb.append(" ");
		return sb.toString();
	}
	
	public static String convertSql(List<Parameter> parameters) {
		// TODO Auto-generated method stub
		if(parameters!=null&&!parameters.isEmpty()){
			StringBuilder sb=new StringBuilder(" ");
			sb.append("order by ");
			int index=0;
			Parameter p;
			Iterator<Parameter> i=parameters.iterator();
			while(i.hasNext()){
				p=i.next();
				if(p instanceof OrderParameter){
					 if(p!=null){
						 if(index>0)
							 sb.append(",");
						 sb.append(p.getTableName());
						 sb.append(".");
						 sb.append(p.getRowName());
						 if(((OrderParameter) p).getSortord()==1)
							 sb.append(" asc");
						 else
							 sb.append(" desc");
						 
						 index++;
					 }
				}
			}
			if(index>0){
				sb.append(" ");
				return sb.toString();
			}
		}
		return null;
	}
	
	public int getSortord() {
		return sortord;
	}

	public void setSortord(int sortord) {
		this.sortord = sortord;
	}
	
	public static void main(String[]args){
		Parameter p =new OrderParameter("goods","name");
		System.out.println("--"+p.convertSql()+"--");
		Parameter p1=new OrderParameter("goods","name",2);
		Parameter p2=new OrderParameter("goods","name");
		Parameter p3=new OrderParameter("goods","name");
		Parameter p4=new OrderParameter("goods","name",2);
		List<Parameter> list=new ArrayList<Parameter>();
		list.add(p);
		list.add(p1);
		list.add(p2);
		list.add(p3);
		list.add(p4);
		System.out.println("--"+OrderParameter.convertSql(list)+"--");
		//System.out.println("--"+p.convertSql()+"--");
	}

	

}


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

/**
 * 分组查询参数基础类
 * @author kaimin  2014/07/01
 *
 */
public class GroupParameter extends Parameter{
	

	public GroupParameter(String tableName,String rowName) {
		super(tableName,rowName);
		// TODO Auto-generated constructor stub
	}

	@Override
	public String convertSql() {
		// TODO Auto-generated method stub
		StringBuilder sb=new StringBuilder(" group by ");
		sb.append(tableName);
		sb.append(".");
		sb.append(rowName);
		sb.append(" ");
		return sb.toString();
	}
	
	public static String convertSql(List<Parameter> parameters) {
		// TODO Auto-generated method stub
		if(parameters!=null&&!parameters.isEmpty()){
			StringBuilder sb=new StringBuilder(" group by ");
			int index=0;
			Parameter p;
			Iterator<Parameter> i=parameters.iterator();
			while(i.hasNext()){
				p=i.next();
				if(p instanceof GroupParameter){
					 if(p!=null){
						 if(index>0)
							 sb.append(",");
						 sb.append(p.getTableName());
						 sb.append(".");
						 sb.append(p.getRowName());
						 index++;
					 }
				}
			}
			if(index>0){
				sb.append(" ");
				return sb.toString();
			}
		}
		return null;
	}
	
	public static void main(String[]args){
		Parameter p =new GroupParameter("goods","name");
		Parameter p1=new GroupParameter("goods","name");
		List<Parameter> list=new ArrayList<Parameter>();
		list.add(p);
		list.add(p1);
		System.out.println("--"+GroupParameter.convertSql(list)+"--");
	}

	

}


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

/**
 * having查询参数
 * @author kaimin  2014/07/01
 *
 */
public class HavingParameter extends ConditionParameter{
	
	/**
	 * 默认构造函数，使用表达式(=)匹配 
	 * @param rowName      列名
	 * @param value        值
	 */
	public HavingParameter(String tableName,String rowName, String value) {
		super(tableName,rowName, value);
		// TODO Auto-generated constructor stub
	}

	/**
	 * @param rowName      列名
	 * @param value        值
	 * @param condition    条件                1--(and) 2--(or)
	 * @param fuzzyMatch   匹配方式      1--(=)  2--(>)  3--(>=)  4--(<) 5--(<=) 6--(%value) 7--(value%) 8--(%value%)
	 */
	public HavingParameter(String tableName,String rowName, String value, int condition,
			int matchMode) {
		super(tableName,rowName, value, condition, matchMode);
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public String convertSql() {
		String sql=super.convertSql();
		if(sql!=null)
			return " having "+sql;
		return null;
	}
	
	public static String convertSql(List<Parameter> parameters) {
		String sql=ConditionParameter.convertSql(parameters);
		if(sql!=null)
			return " having "+sql;
		return null;
	}

	public static void main(String[]args){
		Parameter p;
		List<Parameter> list=new ArrayList<Parameter>();
		for(int i=1;i<9;i++){
			p=new HavingParameter("goods","name","供应",2,i);
			list.add(p);
		    System.out.println("--"+p.convertSql()+"--");
		}
		System.out.println("--"+HavingParameter.convertSql(list)+"--");
	}

}


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

/**
 * where语句参数基础类
 * @author kaimin  2014/07/01
 *
 */
public class WhereParameter extends ConditionParameter{
	

	/**
	 * 默认构造函数，使用表达式(=)匹配 
	 * @param rowName      列名
	 * @param value        值
	 */
	public WhereParameter(String tableName,String rowName, String value) {
		super(tableName,rowName, value);
		// TODO Auto-generated constructor stub
	}

	/**
	 * @param rowName      列名
	 * @param value        值
	 * @param condition    条件                1--(and) 2--(or)
	 * @param fuzzyMatch   匹配方式      1--(=)  2--(>)  3--(>=)  4--(<) 5--(<=) 6--(%value) 7--(value%) 8--(%value%)
	 */
	public WhereParameter(String tableName,String rowName, String value, int condition,
			int matchMode) {
		super(tableName,rowName, value, condition, matchMode);
		// TODO Auto-generated constructor stub
	}
	
	@Override
	public String convertSql() {
		String sql=super.convertSql();
		if(sql!=null)
			return " where "+sql;
		return null;
	}
	
	public static String convertSql(List<Parameter> parameters) {
		String sql=ConditionParameter.convertSql(parameters);
		if(sql!=null)
			return " where "+sql;
		return null;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Parameter p;
		List<Parameter> list=new ArrayList<Parameter>();
		for(int i=1;i<9;i++){
			p=new WhereParameter("goods","name","供应",2,i);
			list.add(p);
		    System.out.println("--"+p.convertSql()+"--");
		}
		System.out.println("--"+WhereParameter.convertSql(list)+"--");

	}

	

	

}


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

/**
 * 查询返回参数基础类
 * @author kaimin  2014/07/02
 *
 */
public class ReturnParameter extends Parameter{

	/**
	 * 
	 * @param tableName   表名
	 * @param rowName     行名     null--*（表示返回所有行）
	 */
	public ReturnParameter(String tableName, String rowName) {
		super(tableName, rowName);
		// TODO Auto-generated constructor stub
	}

	@Override
	public String convertSql() {
		// TODO Auto-generated method stub
		StringBuilder sb=new StringBuilder(" select ");
		sb.append(tableName);
		sb.append(".");
		if(StringUitl.isEmpty(rowName))
			sb.append("*");
		else
			sb.append(rowName);
		sb.append(" ");
		return sb.toString();
	}
	
	public static String convertSql(List<Parameter> parameters) {
		// TODO Auto-generated method stub
		if(parameters!=null&&!parameters.isEmpty()){
			StringBuilder sb=new StringBuilder(" ");
			sb.append(" select ");
			int index=0;
			Parameter p;
			Iterator<Parameter> i=parameters.iterator();
			while(i.hasNext()){
				p=i.next();
				if(p instanceof ReturnParameter){
					 if(p!=null){
						 if(index>0)
							 sb.append(",");
						 sb.append(p.getTableName());
						 sb.append(".");
						 if(StringUitl.isEmpty(p.getRowName()))
							 sb.append("*");
						 else
							 sb.append(p.getRowName());
						 sb.append(" ");
						 index++;
					 }
				}
			}
			if(index>0){
				sb.append(" ");
				return sb.toString();
			}
		}
		return null;
	}
	
	public static void main(String[]args){
		Parameter p=new ReturnParameter("goods","name");
		Parameter p1=new ReturnParameter("goods","id");
		Parameter p2=new ReturnParameter("goods","image");
		List<Parameter> list=new ArrayList<Parameter>();
		list.add(p);
		list.add(p1);
		list.add(p2);
		System.out.println("--"+ReturnParameter.convertSql(list)+"--");
	}

}


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

public class JoinParameter extends Parameter{
	
	private String joinTableName;//连接表名
	
	private String joinRowName;//连接表的依据行
	
	private int style=2;//1--cross join 2--inner  3--left   4--right 5--full 6--self

	public JoinParameter(String tableName,String rowName,String joinTableName,String joinRowName) {
		super(tableName,rowName);
		this.joinTableName=joinTableName;
		this.joinRowName=joinRowName;
		// TODO Auto-generated constructor stub
	}
	
	public JoinParameter(String tableName,String rowName,String joinTableName,String joinRowName,int style) {
		super(tableName,rowName);
		this.joinTableName=joinTableName;
		this.joinRowName=joinRowName;
		this.style=style;
		// TODO Auto-generated constructor stub
	}

	@Override
	public String convertSql() {
		// TODO Auto-generated method stub
		if(StringUitl.isEmpty(tableName)||StringUitl.isEmpty(rowName)
				||StringUitl.isEmpty(joinRowName))
			return null;
		StringBuilder sb=new StringBuilder();
		switch(style){
			case 1  :sb.append(" cross join ");break;
			case 3  :sb.append(" left join ");break;
			case 4  :sb.append(" right join ");break;
			case 5  :sb.append(" full join ");break;
			case 6  :sb.append(" self join ");break;
			default :sb.append(" inner join ");break;
		}
		sb.append(tableName);
		sb.append(" on ");
		sb.append(tableName);
		sb.append(".");
		sb.append(rowName);
		sb.append("=");
		sb.append(joinTableName);
		sb.append(".");
		sb.append(joinRowName);
		sb.append(" ");
		return sb.toString();
	}
	
	public static String convertSql(List<Parameter> parameters) {
		if(parameters==null||parameters.isEmpty())
			return null;
		ListIterator<Parameter> i=parameters.listIterator();
		
		StringBuilder sb=new StringBuilder();
		Parameter p;
		String tableName;
		String rowName;
		String joinTableName;
		String joinRow;
		int style=2;
		int index=0;
		while(i.hasNext()){
			p=i.next();
			if(p==null) 
				continue;
			if(p instanceof JoinParameter){
				tableName=((JoinParameter)p).getTableName();
				joinTableName=((JoinParameter)p).getJoinTableName();
				joinRow=((JoinParameter)p).getJoinRowName();
				style=((JoinParameter)p).getStyle();
				rowName=p.getRowName(); 
				if(StringUitl.isEmpty(tableName)||StringUitl.isEmpty(rowName)
						||StringUitl.isEmpty(joinTableName)||StringUitl.isEmpty(joinRow))
					continue;
				switch(style){
					case 1  :sb.append(" cross join ");break;
					case 3  :sb.append(" left join ");break;
					case 4  :sb.append(" right join ");break;
					case 5  :sb.append(" full join ");break;
					case 6  :sb.append(" self join ");break;
					default :sb.append(" inner join ");break;
			    }
				sb.append(tableName);
				sb.append(" on ");
				sb.append(tableName);
				sb.append(".");
				sb.append(rowName);
				sb.append("=");
				sb.append(joinTableName);
				sb.append(".");
				sb.append(joinRow);
				index=1;
			}
			
		}
		if(index==1){
			sb.append(" ");
			return sb.toString();
		}
		return null;
	}

	public int getStyle() {
		return style;
	}

	public void setStyle(int style) {
		this.style = style;
	}
	
	public String getJoinTableName() {
		return joinTableName;
	}

	public void setJoinTableName(String joinTableName) {
		this.joinTableName = joinTableName;
	}

	public String getJoinRowName() {
		return joinRowName;
	}

	public void setJoinRowName(String joinRowName) {
		this.joinRowName = joinRowName;
	}
	
	public static void main(String[]args){
		Parameter p=new JoinParameter("goods","username","user","name");
		Parameter p1=new JoinParameter("catog","username","user","name");
		List<Parameter> list=new ArrayList<Parameter>();
		list.add(p);
		list.add(p1);
		System.out.println("--"+p.convertSql()+"--");
		System.out.println("--"+JoinParameter.convertSql(list)+"--");
	} 
	

}


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

public class ConditionParameter extends Parameter{
	
    private String value;
	
	private int condition=1;//1--(and) 2--(or)
	
	private int matchMode=1;//1--(=)  2--(>)  3--(>=)  4--(<) 5--(<=) 6--(%value) 7--(value%) 8--(%value%)
	
	/**
	 * 默认构造函数，使用表达式(=)匹配 
	 * @param rowName      列名
	 * @param value        值
	 */
	public ConditionParameter(String tableName,String rowName, String value) {
		super(tableName,rowName);
		this.value = value;
	}

	/**
	 * @param rowName      列名
	 * @param value        值
	 * @param condition    条件                1--(and) 2--(or)
	 * @param fuzzyMatch   匹配方式      1--(=)  2--(>)  3--(>=)  4--(<) 5--(<=) 6--(%value) 7--(value%) 8--(%value%)
	 */
	public ConditionParameter(String tableName,String rowName,String value, int condition, int matchMode) {
		super(tableName,rowName);
		this.value = value;
		this.condition = condition;
		this.matchMode = matchMode;
	}
	
    @Override
	public String convertSql() {
		// TODO Auto-generated method stub
    	if(value==null||value.isEmpty()
    	   ||matchMode<1||matchMode>8)
    		return null;
    	StringBuilder sb=new StringBuilder(" ");
    	sb.append(tableName);
		sb.append(".");
    	sb.append(rowName);
		switch(matchMode){
		   case 1: sb.append("='");sb.append(value);sb.append("'");break;
		   case 2: sb.append(">'");sb.append(value);sb.append("'");break;
		   case 3: sb.append(">='");sb.append(value);sb.append("'");break;
		   case 4: sb.append("<'");sb.append(value);sb.append("'");break;
		   case 5: sb.append("<='");sb.append(value);sb.append("'");break;
		   case 6: sb.append(" like '");sb.append("%");
		           sb.append(value);sb.append("'");break;
		   case 7: sb.append(" like '");sb.append(value);
		           sb.append("%'");break;
		   case 8: sb.append(" like '");sb.append("%");
                   sb.append(value);sb.append("%'");break;
		}
    	sb.append(" ");
		return sb.toString();
	}
    
    /**
     * 将参数集转换为sql语句段
     * 默认第一个条件为and
     * @param parameters  需要转换的参数
     * @return
     */
	public static String convertSql(List<Parameter> parameters) {
		// TODO Auto-generated method stub
		if(parameters!=null&&!parameters.isEmpty()){
			StringBuilder sb=new StringBuilder(" ");
			int index=0;
			Parameter p;
			Iterator<Parameter> i=parameters.iterator();
			String value=null;
			int condition=1;
			int matchMode=1;
			while(i.hasNext()){
				p=i.next();
				if(p instanceof ConditionParameter){
					 if(p!=null){
						 value=((ConditionParameter)p).getValue();
						 matchMode=((ConditionParameter)p).getMatchMode();
						 condition=((ConditionParameter)p).getCondition();
						 if(value==null||value.isEmpty()
					    	   ||matchMode<1||matchMode>8)
					    		continue;
						 if(index>0){
							 if(condition==2)
								 sb.append(" or ");
							 else
								 sb.append(" and ");
						 }
						 sb.append(p.getTableName());
					     sb.append(".");
						 sb.append(p.getRowName());
						 switch(matchMode){
						   case 1: sb.append("='");sb.append(value);sb.append("'");break;
						   case 2: sb.append(">'");sb.append(value);sb.append("'");break;
						   case 3: sb.append(">='");sb.append(value);sb.append("'");break;
						   case 4: sb.append("<'");sb.append(value);sb.append("'");break;
						   case 5: sb.append("<='");sb.append(value);sb.append("'");break;
						   case 6: sb.append(" like '");sb.append("%");
						           sb.append(value);sb.append("'");break;
						   case 7: sb.append(" like '");sb.append(value);
						           sb.append("%'");break;
						   case 8: sb.append(" like '");sb.append("%");
				                   sb.append(value);sb.append("%'");break;
						 }
						 index++;
					 }
				}
			}
			if(index>0){
				sb.append(" ");
				return sb.toString();
			}
		}
		return null;
	}
    
    public String getValue() {
		return value;
	}

	public void setValue(String value) {
		this.value = value;
	}
    
	public int getMatchMode() {
		return matchMode;
	}

	public void setMatchMode(int matchMode) {
		this.matchMode = matchMode;
	}

	public int getCondition() {
		return condition;
	}

	public void setCondition(int condition) {
		this.condition = condition;
	}
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Parameter p;
		List<Parameter> list=new ArrayList<Parameter>();
		for(int i=1;i<9;i++){
			p=new ConditionParameter("goods","name","供应",2,i);
			list.add(p);
		    System.out.println("--"+p.convertSql()+"--");
		}
		System.out.println("--"+ConditionParameter.convertSql(list)+"--");

	}

}


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

/**
 * 查询参数类
 * @author kaimin  2014/07/01
 *
 */
public class QueryParameters {
	
	private String tableName;
	
	private List<Parameter> parameters;
	
	public QueryParameters(String tableName){
		this.tableName=tableName;
		parameters=new ArrayList<Parameter>();
	}
	
	public QueryParameters(String tableName,List<Parameter> parameters){
		this.tableName=tableName;
		if(parameters!=null)
			this.parameters=parameters;
		else
			parameters=new ArrayList<Parameter>();
	}
	
	//将查询参数转换为sql语句
    public String convertSql(){
    	List<Parameter>  returns=new ArrayList<Parameter>();
    	List<Parameter>  where=new ArrayList<Parameter>();
    	List<Parameter>  join=new ArrayList<Parameter>();
    	List<Parameter>  having=new ArrayList<Parameter>();
    	List<Parameter>  group=new ArrayList<Parameter>();
    	List<Parameter>  order=new ArrayList<Parameter>();
    	if(parameters.isEmpty())
    		return null;
    	Iterator<Parameter> i=parameters.iterator();
    	Parameter p;
    	while(i.hasNext()){
    		p=i.next();
    		if(p!=null){
    			if(p instanceof ReturnParameter)
    				returns.add(p);
    			else if(p instanceof WhereParameter)
    				where.add(p);
    			else if(p instanceof HavingParameter)
    				having.add(p);
    			else if(p instanceof GroupParameter)
    				group.add(p);
    			else if(p instanceof OrderParameter)
    				order.add(p);
    			else if(p instanceof JoinParameter)
    				join.add(p);
    			
    		}
    	}
    	String sqlReturn=ReturnParameter.convertSql(returns);
    	String sqlJoin=JoinParameter.convertSql(join);
    	String sqlWhere=WhereParameter.convertSql(where);
    	String sqlhaving=HavingParameter.convertSql(having);
    	String sqlgroup=GroupParameter.convertSql(group);
    	String sqlorder=OrderParameter.convertSql(order);
    	StringBuilder sb=new StringBuilder();
    	if(sqlReturn!=null)
    		sb.append(sqlReturn);
    	sb.append(" from ");
    	sb.append(tableName);
    	if(sqlJoin!=null)
    		sb.append(sqlJoin);
    	if(sqlWhere!=null)
    		sb.append(sqlWhere);
    	if(sqlgroup!=null)
    		sb.append(sqlgroup);
    	if(sqlhaving!=null)
    		sb.append(sqlhaving);
    	if(sqlorder!=null)
    		sb.append(sqlorder);
    	if(sb.length()==0)
    		return null;
    	return sb.toString();
    	
	}

	public boolean add(Parameter parameter){
		return parameters.add(parameter);
	}
	
	public boolean remove(Parameter parameter){
		return parameters.remove(parameter);
	}

	public List<Parameter> getParameters() {
		return parameters;
	}

	public void setParameters(List<Parameter> parameters) {
		this.parameters = parameters;
	}
	
	public String getTableName() {
		return tableName;
	}

	public void setTableName(String tableName) {
		this.tableName = tableName;
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		QueryParameters qp=new QueryParameters("Goods");
		qp.add(new WhereParameter("goods","name","供应",2,1));
		qp.add(new WhereParameter("goods","name","供应",2,2));
		qp.add(new WhereParameter("goods","name","供应",2,6));
		qp.add(new GroupParameter("goods","name"));
		qp.add(new GroupParameter("goods","id"));
		qp.add(new OrderParameter("goods","name",1));
		qp.add(new OrderParameter("goods","id",2));
		qp.add(new HavingParameter("goods","name","供应",2,6));
		qp.add(new JoinParameter("goods","username","goods","name"));
		System.out.println("--"+qp.convertSql()+"--");

	}

}


/**
 * String工具类
 * @author kaimin  2014/07/01
 *
 */
public class StringUitl {
	
	public static boolean isEmpty(String str){
		if(str==null||str.isEmpty())
			return true;
		return false;
	}
	
	public static void main(String[]args){
		System.out.println("--"+StringUitl.isEmpty("")+"--");
	}

}


追逐狂风
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
javaEE Hibernate, HQL面向对象查询语句
houyanhua1的专栏
07-17 232
  Test.java： package cn.xxx.demo; import java.util.List; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import cn.xxx.domain.C...
HQL查询——查询返回对象类型分析
weixin_34160277的博客
03-03 124
关于HQL查询，我们可以结合hibernate的API文档，重点围绕org.hibernate.Query接口，分析其方法，此接口的实例对象是通过通过session、对象的creatQuery(String hql)方法得到的。我这里要分析HQL的select子句，当然要想深入HQL查询，我们就必须了解hibernate缓存的知识。 一、选择——Select子句查询返回对象的讨论 为什么只说S...
HQL简单属性和实体对象查询
残缺的孤独
08-12 5917
在HQL中，关键字不区分大小写，但属性名和类名区分大小写。 1.简单属性查询 （1）单一属性查询：返回的结果集为属性列表，其类型与实体中该属性的类型一致 List students=session.createQuery("select name from Stude
Hibernate - HQL对象检索详解
小小默：进无止境
10-19 826
Hibernate 提供了以下几种检索对象的方式： 导航对象图检索方式: 根据已经加载的对象导航到其他对象 OID 检索方式: 按照对象的 OID 来检索对象 HQL 检索方式: 使用面向对象的 HQL 查询语言 QBC 检索方式: 使用 QBC(Query By Criteria) API 来检索对象. 这种 API 封装了基于字符串形式的查询语句, 提供了更加面向对象的查询接口. 本地 ...
HQL查询对象实战详解
oLengYueHun的博客
04-02 434
1.项目结构及目标数据库： 2.hql配置文件： <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate...
HQL：使用面向对象的HQL查询语言
Paige's Blog
06-18 1540
Query接口 1.不可省略的form String hql="form Student"; //创建Query实例 Query query = Session.createQuery(hql); //执行HQL调用list()，返回List集合 List studentList = query.list();2.select //别名的使用 String hql="select s.nam
基于JPQL实现纯SQL语句方法详解
12-14
基于首次在EJB2.0中引入的EJB查询语言(EJB QL),Java持久化查询语言(JPQL)是一种可移植的查询语言，旨在以面向对象表达式语言的表达式，将SQL语法和简单查询语义绑定在一起·使用这种语言编写的查询是可移植的，可以...
hibernate精华教程
10-24
要使用HQL（HibernateQueryLanguage）查询语句，HQL查询语句是面向对象的，它引用类名及类的属性名。 select/update/delete…… from …… where …… group by …… having …… order by …… asc/desc ...
2023Java高频面试题
最新发布
06-13
Java面试题主要涉及Java语言本身、常用的Java框架和技术、面向对象编程、多线程编程、算法和数据结构等方面。通常包括以下主要内容： Java基础知识：Java的基本数据类型、变量、运算符、控制语句等基础概念。 面向...
达内java培训目录
02-06
Java面向对象 面向对象特性：封装、继承、多态等，面向对象程序设计，基础设计模式等。 掌握面向对象的基本原则以及在编程实践中的意义；掌握Java面向对象编程基本实现原理。 实训项目一：Tetris项目开发 第二阶段...
Spring Data JPA笔记.zip
02-02
JPA 的全称是 Java Persistence API， 即 Java 持久...JPA 的查询语言是面向对象而非面向数据库的，它以面向对象的自然语法构造查询语句，可以 看成是 Hibernate HQL 的等价物。 本文档包含了JPA的课件笔记与学习标注。
HQL语法大全，并带有详细的例子
03-22
HQL是完全面向对象的查询语言，因此可以支持继承和多态等特征。HQL查询依赖于Query类，每个Query实例对应一个查询对象，使用HQL查询按 如下步骤进行： (1)获取Hibernate Session对象； (2)编写HQL语句； (3)以HQL语句作为参数，调用Session的createQuery方法创建查询对象； (4)如果HQL语句包含参数，调用Query的setXxx方法为参数赋值； (5)调用Query对象的list等方法遍历查询结果。
【Hibernate步步为营】--hql查询之实体对象查询
热门推荐
航帆远洋
06-10 1万+
实体对象查询是hql查询的基础，作为一种对象查询语言，在查询操作时和sql不同，查询字符串中的内容要使用类名和类的属性名来代替。这种查询方法相对简单，只要有SQL功底，使用hql是很简单的，但是有一些问题需要注意，就是查询获取数据不是目的，需要考虑的是如何编写出高效的查询语句，这才是讨论的重点。
Hibernate 的hql 查询，然后转换为对象
m0_37626203的博客
05-15 1650
 Hibernate 的hql 查询，如果绑定的话，一下查询，会查询所有绑定的数据。这个不用多说，但是，如果查询的时候，因为前台需要展示出来，但是，关联关系比较复杂，到时候，展示出来也比较复杂。比如我用的是easyui展示到datagrid 中。那个需要转化。虽然转化比较简单，但是，每一个都写的话，也很麻烦。但是，在后台转换为一个对象，也比较麻烦。使用自己斟酌。哪个麻烦，哪个简单，由你来定。   ...
Hibernate查询时用HQL动态创建对象
王洋的专栏
02-23 7878
当你在实际的开发过程中，有时候查询的结果只是需要查询一张表中的一部分数据，而不是所有的数据，比如说，我现在有一个需求是这样的：我只需要user的id和name这两个属性的数据，其他的数据暂时不需要，那么这时候如果按照原来（假设原来user表中数据包括：userId,userName,teleNum,email等等的个人信息）的对象直接将整个对象全部获取到，这是牺牲性能作为代价的，一个user的时候
【hibernate】——hql简单属性+实体对象查询
漫漫长途，终有回转；余味苦涩，终有回甘
06-05 2041
最近一直在研究hibernate，真是觉得越深入乐趣越多，由衷佩服hibernate的开发者，真正的体验到什么时灵活自如！真的很喜欢！     本文小编主要讲解hibernate中原生sql在查询简单属性和实体对象的怎么使用，以及几种不同的参数查询。     简单属性查询 1】 单个属性 //返回结果集属性列表，元素类型和实体类中的属性类型一致，其中Student对应的是程序中实体 L
使用hql动态创建对象问题
weixin_33901926的博客
04-19 77
前段时间由于需求要添加报表数据，调整ireport后，打印pdf文件出现数据错位的情况，调试发现不是ireport问题，就查看了后台传送的数据，最后发现传送的对象属性值已经就是错位的，那就是获取对象时出的问题，查看了查询语句，发现问题了，查询时使用hql动态创建对象，但查询语句中对象的属性顺序跟该对象带参构造函数中传参的顺序没有一一对应，也就是，比如以下对象User： publi...
hql相较于SQL有什么优势
05-25
HQL（Hibernate Query Language）是一种基于对象的查询语言，它是Hibernate框架中用来查询数据的语言，相较于传统的SQL查询语言，具有以下优势： 1. 对象导向：HQL是基于对象的查询语言，它支持类、属性和方法等面向对象的概念，使得查询更加直接和自然。 2. 易于维护：使用HQL能够有效地减少SQL语句中的硬编码，因此，当数据库模式发生变化时，只需要改变对象映射文件，而不需要修改查询语句本身，从而减少了维护的难度。 3. 可移植性：由于HQL是基于对象的，因此它与具体的数据库无关，使得应用程序更加可移植。 4. 灵活性：HQL支持动态查询，使得查询语句更加灵活，可以根据具体的需求进行态组合。 5. 性能优化：HQL提供了很多化查询的方法，如存查询结果、分页查询、延迟加载等，能够有效地提查询性能。 总之，HQL是一种基于对象的查询语言，相较于传统的SQL语言具有更好的面向对象性，易于维护，移植性和更好的性能优化等优势。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值