HQL查询-分页-条件-连接-过滤使用

最新推荐文章于 2023-07-14 21:35:59 发布
最新推荐文章于 2023-07-14 21:35:59 发布
阅读量4k 收藏 5
点赞数 1
分类专栏： hibernate 文章标签： hql查询 hql分页 hql条件 hql连接 hql过滤
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011159417/article/details/75665573
版权

HQL(Hibernate Query Language)是hibernate自带的查询语言，进行了面向对象的分装，今天就来学习一下，


新建一个java项目，结构如下：



jar包和hibernate官网使用，参见《Hibernate环境搭建和配置》


实体类Book代码：

package com.myeclipse.pojo;

import java.util.Date;
public class Book {
	
	private int id;
	private String author;
	private String name;
	private double price;
	private Date pubDate;
	private Category category;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getAuthor() {
		return author;
	}
	public void setAuthor(String author) {
		this.author = author;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public Date getPubDate() {
		return pubDate;
	}
	public void setPubDate(Date pubDate) {
		this.pubDate = pubDate;
	}
	public Category getCategory() {
		return category;
	}
	public void setCategory(Category category) {
		this.category = category;
	}
	@Override
	public String toString() {
		return "Book [id=" + id + ", author=" + author + ", name=" + name
				+ ", price=" + price + ", pubDate=" + pubDate + "]";
	}
	
	
}

Book.hbm.xml代码如下： 

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.myeclipse.pojo">
	<class name="Book" table="t_book">
		<id name="id">
			<generator class="identity" />
		</id>
		<many-to-one name="category" class="Category" column="category_id" />
		<property name="author" />
		<property name="name" column="book_name" />
		<property name="price" />
		<property name="pubDate" />
		<!-- 使用过滤器 -->
		<filter name="bookFilter" condition="id=:id"></filter>

	</class>
	<!-- 过滤器定义 : 定义参数 -->
	<filter-def name="bookFilter">
		<filter-param name="id" type="integer" />
	</filter-def>

</hibernate-mapping>

Category实体类代码： 


package com.myeclipse.pojo;

import java.util.HashSet;
import java.util.Set;

public class Category{
	
	private int id;
	private String name;
	private Set<Book> books = new HashSet<Book>();

	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set<Book> getBooks() {
		return books;
	}
	public void setBooks(Set<Book> books) {
		this.books = books;
	}

}

Category.hbm.xml代码如下： 


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
   "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
	
	
<hibernate-mapping package="com.myeclipse.pojo">
	<class name="Category" >
		<id name="id" >
			<generator class="identity" />
		</id>
		<property name="name" />
		<set name="books" inverse="true">
			<key>
				<column name="category_id" />
			</key>
			<one-to-many class="Book" />
		</set>
	</class>

</hibernate-mapping>

hibernate.cfg.xml代码： 


<!DOCTYPE hibernate-configuration PUBLIC
	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
<session-factory>
	<!-- 配置数据库连接信息 -->
	<property name="connection.driver_class">
		com.mysql.jdbc.Driver
	</property>
	<property name="connection.url">jdbc:mysql:///hibernate4</property>
	<property name="connection.username">root</property>
	<property name="connection.password">root</property>
	<!-- 数据库方言 -->
	<property name="hibernate.dialect">
		org.hibernate.dialect.MySQL5Dialect
	</property>
	<!-- 是否打印sql语句 -->
	<property name="show_sql">true</property>
	<!-- 格式化sql语句 -->
	<property name="format_sql">true</property>
	<!-- 数据库更新方式： 
		1、create：每次更新都先把原有数据库表删除，然后创建该表；
		2、create-drop:使用create-drop时，在显示关闭SessionFacroty时（sessionFactory.close()），将drop掉数据库Schema（表） 
		3、validate：检测；
		4、update（常用）：如果表不存在则创建，如果存在就不创建
	-->
	<property name="hbm2ddl.auto">update</property>
	<!-- hbm映射文件 -->
	<mapping resource="com/myeclipse/pojo/Book.hbm.xml"/>
	<mapping resource="com/myeclipse/pojo/Category.hbm.xml"/>

</session-factory>
</hibernate-configuration>


HibernateUtil代码：


package com.robert.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
import org.hibernate.cfg.Configuration;

/**
 * hibernate工具类
 */
public class HibernateUtil {

	private static Configuration cfg = null;
	private static SessionFactory factory = null;
	private static Session session = null ;
	
	static {
		init();
	}

	/**
	 * 初始化获得Configuration和SessionFacroty对象
	 */
	public static void init() {
		cfg = new Configuration().configure();
		factory = cfg.buildSessionFactory(new StandardServiceRegistryBuilder()
				.applySettings(cfg.getProperties()).build());
	}

	/**
	 * 获得Session对象
	 * @return
	 */
	public static Session getSession() {
		if (factory != null){
			return session = factory.openSession();
		}
		

		init();
		return session = factory.openSession();
	}
	
	/**
	 * 关闭Session
	 */
	public static void closeSession() {
		if(session!=null && session.isOpen())
			session.close();
	}

}

HibernateTest测试类代码，包含创建数据库表，保存数据，查询 


package com.ghibernate.test;

import java.util.Date;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;
import org.junit.Test;

import com.myeclipse.pojo.Book;
import com.myeclipse.pojo.Category;
import com.robert.util.HibernateUtil;

public class HibernateTest {

	@Test
	public void testCreateDB() {
		Configuration cfg = new Configuration().configure();
		SchemaExport se = new SchemaExport(cfg);
		// 第一个参数：是否生成ddl脚本
		// 第二个参数：是否执行到数据库中
		se.create(true, true);
	}

	@Test
	public void testSave() {

		Session session = HibernateUtil.getSession();
		Transaction tx = session.beginTransaction();

		Category category = new Category();
		category.setName("文学");
		Category category1 = new Category();
		category1.setName("历史");
		Category category2 = new Category();
		category2.setName("仙侠");
		Category category3 = new Category();
		category3.setName("科幻");
		Category category4 = new Category();
		category4.setName("恐怖");

		Book book = new Book();
		book.setName("读者");
		book.setPrice(5.6);
		book.setAuthor("众人");
		book.setPubDate(new Date());
		book.setCategory(category);

		Book book1 = new Book();
		book1.setName("傲慢与偏见");
		book1.setPrice(80.0);
		book1.setAuthor("简.奥斯汀");
		book1.setPubDate(new Date());
		book1.setCategory(category1);

		Book book2 = new Book();
		book2.setName("中国历史");
		book2.setPrice(30.0);
		book2.setAuthor("人民出版社");
		book2.setPubDate(new Date());
		book2.setCategory(category1);

		Book book3 = new Book();
		book3.setName("翩眇之旅");
		book3.setPrice(70.0);
		book3.setAuthor("萧鼎");
		book3.setPubDate(new Date());
		book3.setCategory(category2);

		Book book4 = new Book();
		book4.setName("蓝血人");
		book4.setPrice(60.0);
		book4.setAuthor("卫斯理");
		book4.setPubDate(new Date());
		book4.setCategory(category3);

		Book book5 = new Book();
		book5.setName("我的大学");
		book5.setPrice(60.5);
		book5.setAuthor("高尔基");
		book5.setPubDate(new Date());
		book5.setCategory(category);

		session.save(book);
		session.save(book1);
		session.save(book2);
		session.save(book3);
		session.save(book4);
		session.save(book5);
		session.save(category4);

		tx.commit();
		HibernateUtil.closeSession();

	}

	@Test
	public void testGet() {

		Session session = HibernateUtil.getSession();
		Transaction tx = session.beginTransaction();

		Book book = (Book) session.get(Book.class, 1);
		System.out.println("book_name=" + book.getName() + "-----category="
				+ book.getCategory().getName());

		tx.commit();
		HibernateUtil.closeSession();

	}

	/**
	 * 查询所有书名
	 */
	@Test
	public void testQuery() {
		Session session = HibernateUtil.getSession();
		String hql = "select name from Book";
		Query query = session.createQuery(hql);
		List<String> list = query.list();
		for (String bookname : list) {
			System.out.println(bookname);
		}

	}

	/**
	 * 查询返回多个列
	 */
	@Test
	public void testQueryMoreElements() {
		Session session = HibernateUtil.getSession();
		String hql = "select name, price from Book";
		Query query = session.createQuery(hql);
		// 查询多个列时，返回结果是数组集合，数组中元素的类型是有查询列来决定的
		List<Object[]> list = query.list();
		for (Object[] objs : list) {
			System.out.println(objs[0] + "--------" + objs[1]);
		}

	}

	/**
	 * 查询返回对象
	 */
	@Test
	public void testQueryObject() {
		Session session = HibernateUtil.getSession();
		Transaction tx = session.beginTransaction();
		String hql = "select new Book(name, price) from Book";
		Query query = session.createQuery(hql);
		// 查询多个列时，返回结果是数组集合，数组中元素的类型是有查询列来决定的
		List<Book> list = query.list();
		for (Book book : list) {
			System.out.println(book);
		}
		tx.commit();
		HibernateUtil.closeSession();

	}

	/**
	 * 查询所有列
	 */
	@Test
	public void testQueryAll() {
		Session session = HibernateUtil.getSession();
		Transaction tx = session.beginTransaction();
		String hql = " from Book";
		Query query = session.createQuery(hql);
		List<Book> list = query.list();
		for (Book book : list) {
			System.out.println(book);
		}
		tx.commit();
		HibernateUtil.closeSession();

	}

	/**
	 * 条件查询:使用占位符，从0开始
	 */
	@Test
	public void testQueryWhereConfition() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " from Book where id < ? or price < ?";
			// String hql = " from Book where id < ? and price < ?" ;
			// setInteger：第一个参数是0表示第一个从占位符，第二个参数表示第一个占位符的值
			// setDouble：第一个参数是1，表示第二个占位符，第二个参数表示第二个占位符的值
			Query query = session.createQuery(hql).setInteger(0, 4)
					.setDouble(1, 400);
			;
			List<Book> list = query.list();
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 条件查询:使用占位符，从0开始
	 */
	@Test
	public void testQueryWhereSetParameter() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " from Book where id < ? ";
			// setParameter不用管参数的类型
			Query query = session.createQuery(hql).setParameter(0, 4);
			List<Book> list = query.list();
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 条件查询之命名查询,以冒号开头，后跟名称，在setParameter时，将该名称放进去即可
	 */
	@Test
	public void testQueryWhereSetName() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " from Book where id <:id ";
			// setParameter不用管参数的类型
			Query query = session.createQuery(hql).setParameter("id", 4);
			List<Book> list = query.list();
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 分页查询
	 */
	@Test
	public void testQueryPaging() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " from Book ";
			// setFirstResults:数据从第几个开始显示（currentPage-1）*PageSize
			// setMaxResults：每页显示的数据数量PageSize
			Query query = session.createQuery(hql).setFirstResult(3)
					.setMaxResults(3);
			List<Book> list = query.list();
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 聚合函数----统计查询
	 * 结果唯一
	 */
	@Test
	public void testQueryStatistics() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " select count(b.name) from Book b ";
			Object count = session.createQuery(hql).uniqueResult() ;
			System.out.println("总数："+count);
			
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}


	/**
	 * 分组查询
	 */
	@Test
	public void testQueryGroupBy() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " select b.category.name  , count(b.id) from Book b group by b.category.name ";
			List<Object[]> list = session.createQuery(hql).list() ;
			for (Object[] objs : list) {
				System.out.println(objs[0]+"---"+objs[1]);
			}
			
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
	
	/**
	 * 排序查询
	 */
	@Test
	public void testQueryOrderby() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			String hql = " from Book b Order by b.price desc ";
			List<Book> list = session.createQuery(hql).list() ;
			for (Book book : list) {
				System.out.println(book);
			}
			
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	/**
	 * 对象导航
	 */
	@Test
	public void testQueryNavigation() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			//查询“仙侠”类的书籍信息
			String hql = " from Book b where b.category.name =:name  ";
			hql = " select b from Book b join b.category c where c.name =:name" ;
			hql = " select b from Book b inner join b.category c where c.name =:name" ;
			
			List<Book> list = session.createQuery(hql).setString("name", "仙侠").list() ;
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
	
	/**
	 * 左外连接
	 */
	@Test
	public void testQueryLeftJoin() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			//查询“仙侠”类的书籍信息
			String hql = " select c.name , b.name from Category c left outer join c.books b ";
			List<Object[]> list = session.createQuery(hql).list() ;
			for (Object[] objs : list) {
				System.out.println(objs[0]+"---"+objs[1]);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
	
	/**
	 * 过滤器的使用--过滤查询--为查询加上某些条件
	 * 过滤器的步骤：
	 * 1、定义过滤器；
	 * 2、使用过滤器-加条件；
	 * 3、查询时，是过滤器生效
	 */
	@Test
	public void testQueryFilter() {
		try {
			Session session = HibernateUtil.getSession();
			Transaction tx = session.beginTransaction();
			//启用过滤器
			session.enableFilter("bookFilter").setParameter("id", 4) ;
			//查询“仙侠”类的书籍信息
			String hql = " from Book b ";
			List<Book> list = session.createQuery(hql).list() ;
			for (Book book : list) {
				System.out.println(book);
			}
			tx.commit();
			HibernateUtil.closeSession();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}

	
}

具体的结果自己运行一下就可以了。







Java红桃峰峰日拱一卒
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA程序开发大全---上半部分
12-15
9.3.2 使用HQL编辑器 154 9.4 Hibernate应用实例：基于Struts+Hibernate的登录系统 155 9.5 本章小结 160 第10章 Spring框架的开发及应用 161 10.1 Spring框架概述 161 10.2 Spring框架中的IoC编程 162 10.2.1 控制...
Hibernate的HQL选择、投影、排序、分页、聚合分组、连接查询、QBC分页、排序、条件、离线查询、hibernate整合c3p0连接池、事务隔离级别、hibernate中设置隔离级别-day04
ShuYY的博客
09-04 1107
目录第一节 HQL查询1.1 HQL简介1.2 案例1：查询所有客户1.3 案例2：选择查询1.4 案例3：投影查询1.5 案例4：排序1.6 案例5：分页1.7 案例6：聚合函数和分组查询1.8 案例7：连接查询1.交叉连接 ，等效 sql 笛卡尔积2.隐式内连接，等效 sql 隐式内连接3.内连接，等效sql内连接4.迫切内连接，hibernate底层使用内连接5.左外连接，等效sql左外连接6.内连接与左外连接的区别7.迫切左外连接，hibernate底层使用左外连接8.右外连接（迫切），等效sql右
Hibernate之HQL添加过滤器查询的用法
weixin_33858485的博客
03-08 139
　　HQL查询过程中支持添加过滤器.使用步骤是这样的: 　　首先在要查询的实体对象的映射中使用&lt;filter-def&gt;标签配置过滤器，并在相对应的&lt;class&gt;标签中添加对应的&lt;filter&gt;过滤器；然后在对应的程序文件中使用enableFilter()方法启动过滤器，为过滤器定义的参数赋值，在执行时就会自动自行对应的过滤器 以上一节的Book和Catego...
hibernate的hql通用分页(BaseDao)和原生SQL以及视图映射
qq_41997812的博客
10-30 554
①传统的hibernate通用分页： ①需要用的助手类： 分页助手类 package com.zking.eight.util; import java.util.Map; import javax.servlet.http.HttpServletRequest; /** * 分页工具类 * */ public class PageBean { private int page =...
SQL中过滤条件 on和where中的区别
ishulei的博客
09-14 2341
今天考试的时候用到 了sql语句，原题的要求是 .查询同时参加计算机和英语考试的学生信息 ，凭借着固有的思维模式写出了 SELECT ST.* FROM STUDENT ST INNER JOIN SCORE SC ON ST.ID=SC.STUDENT_ID WHERE SC.COURSE_NAME= ‘英语’ and SC.COURSE_NAME=’计算机’ 返回的...
分页查询实现
最新发布
xfk_DO的博客
07-14 920
代码正常运行的时候，repositoty层的调用者是service层，作为调用者就必须要是别PageInfo，调用者为了调用分页功能的方法，必须要有PageInfo的导包语句，问题就来了，如果未来程序要变动，将不使用PageHelper分页框架，那么service层的调用分页功能的导包语句也就会用不了，这样的话，service层也就依赖了PageHelper框架，不使用PageHelper框架就会导致service层也要改动。：加上此注解，它改变了对象属性的set方法的返回值，返回当前的对象。
Java学习笔记-个人整理的
12-19
{13.5}分页查询}{196}{section.13.5} {13.5.1}MySQL}{198}{subsection.13.5.1} {13.6}连接池}{199}{section.13.6} {13.6.1}Wrapper}{199}{subsection.13.6.1} {13.7}DAO}{199}{section.13.7} {13.8}java.util....
最全Hibernate 参考文档
08-29
10.4.3. 条件查询(Criteria queries) 10.4.4. 使用原生SQL的查询 10.5. 修改持久对象 10.6. 修改脱管(Detached)对象 10.7. 自动状态检测 10.8. 删除持久对象 10.9. 在两个不同数据库间复制对象 10.10. Session刷出...
精通 Hibernate：Java 对象持久化技术详解(第2版).part2
06-12
　17.2 设定查询条件 　17.2.1 比较运算 　17.2.2 范围运算 　17.2.3 字符串模式匹配 　17.2.4 逻辑运算 　17.2.5 集合运算 　17.3 小结 　17.4 思考题 第18章 Hibernate的检索方式（下） 　18.1 连接查询 　18.1.1 ...
hibernate分页查询
08-12
hibernate分页查询，里面包含数据库。自己写的。能正常运行。
Hibernate分页查询小结
09-20
Hibernate分页查询小结
HQL查询及分页查询
前路漫漫，少年，继续披荆斩棘！
12-08 374
HQL查询及分页查询
HQL--分页查询
一尺经年的博客
06-21 361
分页查询 @Test public void showpage() { SessionFactory sf = null; sf = HiberUnti.getSessionFatory(); Session se = sf.getCurrentSession(); Transaction ts = se.beginTransaction(); String sql = "from User"; try
HQL通用分页
ahong_1920的博客
12-03 840
HQL通用分页 HQL分页的思路: HQL传过来,拼接countHql 给命名参数赋值(hibernate 5.0 以后占位符?基本不用了) pageBean setTotal（设置符合条件的总页数） 查询你需要的结果集 命名参数赋值 /** * 给命名参数赋值 * * @param query 预定义参数 * @param map 接受参数 */ public vo...
摘录HSQL几个使用细节
Michael's notes.
01-12 1650
1. 有关分页查询：使用内存数据库HSQLDB进行分页查询时，需要用类似Oracle中的rownum来进行“按结果集的行号查询”操作，此时需要注意：HSQLDB的SQL语句不支持rownum，但是提供limit(格式为select limit startIndex recordCount * from xtable where xcondition)来进行按行号查询。其中startIndex为起始
Hsql 查询
通往IT大道的专栏
07-11 1423
还是班级，学省
hibernate hql 分页查询
iteye_12724的博客
07-20 238
今天封装了自己的hibernateDao，主要是基于hql的，期间遇到一个问题，最后解决了，和大家分享分享 其他hibernate的查询，像QBE，QBC，这些就不说了，如果用hibernate还是hql最强大，也很容易上手 先上代码，这里只列出主要代码 [code="java"]/**      * hql分页查询      *      * @param hql   ...
分页查询的通用方法
weixin_44035488的博客
06-01 141
// 分页查询的通用方法 public void QueryByPage(int pageSize) { SessionFactory sf = null; Session session = null; Transaction ts = null; try { sf = HibernateUtil.getSessionFactory();// SessionFactory单态模式 session = sf.getCurr.
hibernate之Hql ->update语句的用法
05-26
Hibernate中的HQL语句可以用于执行更新操作。HQL的update语句的语法如下： ``` update EntityName set property1 = :value1, property2 = :value2 where condition ``` 其中，EntityName为要更新的实体类名称，property1、property2等为要更新的实体类属性名称，:value1、:value2等为要更新的属性值，condition为更新条件。 示例代码： ``` String hql = "update User set name = :newName where id = :id"; Query query = session.createQuery(hql); query.setParameter("newName", "NewName"); query.setParameter("id", 1); int result = query.executeUpdate(); ``` 上述代码中，执行了一条更新语句，将名为“NewName”的值更新到id为1的User实体的name属性中。最后，执行executeUpdate()方法得到更新的结果数量。 需要注意的是，在HQL的update语句中，更新操作是直接对数据库进行操作，不会触发实体类的更新。如果需要同时更新实体类中的属性值，需要在更新数据库之后，手动更新实体类中的属性值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值