Hibernate 基础

最新推荐文章于 2020-06-03 21:23:49 发布

weixin_38168918

最新推荐文章于 2020-06-03 21:23:49 发布

阅读量75

点赞数

原文链接：http://www.cnblogs.com/yuan211/p/8334661.html

版权

写在框架学习之前：请务必建立手动查文档的能力，主动学习
http://www.hibernate.org/downloads/

一：
1、导包：
hibernate4+oracle->window->preferences->java->build path->user libraries
build path->add libraries->user library->选择用户库

4.1以后的hbm2ddl配置update也能建表(不存在的情况下)，只是不会显示建表语句，create无论什么时候都创建(有则删除),而且显示语句

2、配置：
hibernate.cfg.xml
a、从manual参考文档中copy或者从hibernate核心包中参考*.dtd
b、修改对应的数据库连接
c、注释掉用不上的内容
xml注释：ctrl+shift+c和ctrl+shift+/|ctrl+shift+\
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

注意：hbm2ddl.auto
create:每次启动删除重建
update:启动检查实体类和表是否一致，没有重建，不一致修改表结构(不能删除列)
create-drop:创建工厂建表，关闭工厂删除
validate:启动验证实体类和表是否一致，不一致抛异常

3、创建实体类及映射文件(规范：类名和文件名相同,放在同一包下)
Student.hbm.xml Student.java (pojo:Plain Ordinary Java Object)
@Annotation选择javax.persistence包下的(jpa包)

a、从参考文档中copy或者从hibernate核心包中参考*.dtd
b、将映射文件配置到hibernate.cfg.xml

4、工具类HibernateUtil
4.0前的写法：只读取hibernate.cfg.xml
Configuration cfg = new Configuration().configure();
SessionFactory factory = cfg.buildSessionFactory();
Session session = factory.openSession();

4.0后的新写法：会读取hibernate.properties，hibernate.cfg.xml只能设置映射文件
Configuration cfg = new Configuration().configure();
ServiceRegistry service = new ServiceRegistryBuilder().applySettings(cfg.getProperties()).buildServiceRegistry();
SessionFactory factory = cfg.buildSessionFactory(service);
Session sess = factory.openSession();

注意：
1、configure()方法默认读的是classes目录下的hibernate.cfg.xml如果改了则要
configure('新文件')
hibernate.cfg.xml:show_sql、format_sql

2、Oracle表名和列名不支持_开头

3、文档中有帮助类HibernateUtil

annotation:@Entity @Table(name="表名") @Id @GeneratedValue @Column

hibernate可以自动识别java.sql.Date和java.util.Date

不需要持久化的字段：
xml:不配置,xml中配置了属性就必须存在(实际是去寻找get和set方法)
annotation:@Transient

*****************************************************************************************

二：
JUnit4的Bug:
@BeforeClass
public static void setUpBeforeClass() throws Exception {
//这里configure()出错不报异常，使用try catch或用main()方法解决
Configuration cfg = new AnnotationConfiguration().configure();
factory = cfg.buildSessionFactory();
}

openSession()方法和getCurrentSession()(ThreadLocal<T>)方法的区别：
openSession():始终打开的是新的session,必须要手动close(),查询可以不用事务(不用begin和commit)
getCurrentSession():他是从当前上下文环境中取一个session，如果第二次调用的时候他仍然会去取同一个，事务提交的时候自动close();不能手动close;
必须配置
<property name="current_session_context_class">thread</property>

Hibernate对象的三种状态：id=主键
瞬时状态transient：对象只存在于内存中，缓存和数据库中都没有id
save() saveOrUpdate()将对象变为持久化状态

持久化状态persistent: 内存中有id，缓存中有id，数据库也有id

游离状态detached:(脱管)内存中有id，缓存中没有id，数据库有id sess.close()

核心开发接口
Configuration SessionFactory
session常用方法：
get()：先检查缓存(session)，没有该对象立马发sql,如果对象不存在返回null
load()：始终返回代理对象($$)，需要用到该对象的时候才检查缓存，没有才发sql，session关闭后再用到也将异常no session，get()较常用，load()不常用(可以使用Hibernate.initialize()加载)

update()：必须数据库有对应记录(id)才更新，默认更新所有字段，持久状态更新前会检查有没有改变，没有不发sql,即使不用update只要提交事务也会检查session和数据库是否一致(脏检查)，不一致也会发sql,dynamic-update(持久状态)不更新没有改动的字段

delete()：删除，对象变成瞬时状态(只要对象的id在数据库存在就可以删除)

save()：不管怎样都保存，即使有和数据库相同的id

saveOrUpdate()：对象存在id(游离状态)则update，如果数据库有id则成功update没有对应的id则异常，对象没有id(瞬时状态)则save，通过这个方法可以将保存和更新两个业务合并

merge()：合并类似saveOrUpdate，先查询出来(持久状态)和现有对象做比较，然后动态更新，如dynamic-update在跨session的时候就只能用merge()实现动态更新，如果瞬时状态也将做保存操作
注意：merge其返回类型是Object(始终持久状态)、saveOrUpdate无返回，
merge不改变参数对象的状态、saveOrUpdate将参数状态变为持久状态

clear()：强制清空缓存，让对象变成游离状态
evict(obj)：将对象实例从session缓存清除，该对象变为游离状态
flush()：默认强制缓存和数据库同步一下，对象变为持久状态，但没有提交还可以回滚session没有关闭
session在commit的时候其实也flush了，也可以设置FlushMode(很少用)sess.setFlushMode()
Hibernate按照insert,update,delete的顺序提交所有登记的操作

只更新改变了值的字段：
1：dynamic-update
annotation:@DynamicUpdate(hibernate的包非jpa)

2：使用hql更新

*****************************************************************************************

三、
A、id生成策略：
xml查文档:
increment(使用max(id)函数查询再插入，不能用于集群)
native
sequence
identity
assigned:程序赋值
uuid|uuid2(Universally Unique Identifier|通用唯一标识符)

annotation查文档(JavaEE文档)4种：
1、AUTO(直接写 @GeneratedValue 相当如native)
i.默认：对 MySQL,使用auto_increment
ii.对 Oracle使用hibernate_sequence(名称固定）
2、IDENTITY(@GeneratedValue(strategy=GenerationType.IDENTITY))(sqlserver和mysql)
3、SEQUENCE(@GeneratedValue(strategy=GenerationType.SEQUENCE,generator="sss"))(oracle)
@SequenceGenerator(name="sss",sequenceName="tea_seq")
4、UUID:@GenericGenerator
@Id
@GeneratedValue(generator="system-uuid")
@GenericGenerator(name="system-uuid",stratege="uuid")

B、关联映射：对象间的关系，一共7种
查文档：
一对一：（少用,可以合成一张表，数据库表一般设计成单向外键关联或主键关联）
外键关联：(注意注解要么都写在属性上，要么都写在方法上)
单向：@OneToOne <many-to-one unique="true"/>
双向：@OneToOne(MappedBy，意思是由哪边维护关联关系，相当与xml中的property-ref)
<many-to-one unique="true"/> 两个都用<many-to-one/>也会生成两个外键
<one-to-one property_ref=""/>(property_ref相当于MappedBy，必须设置否则连表查询语句条件会有错)

注意：
1、对于双向关联除了双向主键关联，annotation必须加MappedBy(否则会产生冗余外键)
2、设置MappedBy还可以在添加(save)的时候由对方设置关联关系(setXxx)不再需要两边都设置

(特别特别重要)
一对多：数据库中是在多的一方加外键
单向：Set @OneToMany <One-To-Many />
多对多的特殊形式，默认有中间表，加@JoinColumn解决

多对一：
单向: @ManyToOne <Many-To-One /> 可以省略@JoinColumn不会产生中间表
双向: 默认产生两个外键字段
annotation:@OneToMany(mappedBy="")(只有@OneToMany有mappedBy @ManyToOne没有，也就是说由多的一方维护关系)
xml:<key>里的column必须和<many-to-one>的column保持一致

多对多：(单向的比较重要)
单向：
<set name="roles" table="ur">
<key column="ur_uid" />
<many-to-many class="Role" column="ur_rid"></many-to-many>
</set>
双向：(双向的时候要设置inverse，否则关联对象如果两边设置关系会造成在中间表插入相同记录，将违反主键约束)
<set name="users" table="ur" inverse="true" >
<key>
<column name="ur_rid"></column>
</key>
<many-to-many class="Users" column="ur_uid"></many-to-many>
</set>

annotation：
@ManyToMany(如果不设MappedBy将产生两张中间表，两张表都将维护双方关系，而xml如果不设置inverse会在一张中间表中插入相同记录而违反主键约束(联合主键))
设置中间表和外键列：
@JoinTable(name="ur",joinColumns={@JoinColumn(name="ur_uid")},
inverseJoinColumns={@JoinColumn(name="ur_rid")})

关联对象的CRUD(cascade)
cascade:只影响增删改(多对多不影响删除)，fetch影响查 (mappedBy对应xml中的inverse)

1、在@ManyToOne取多一方的时候默认会取一的一方(EAGER)，而取一方的时候默认不取多(LAZY)，我们一般采用默认就行，如果两边都使用eager会发多条sql语句，影响性能。
如：Wife2 w = (Wife2)sess.get(Wife2.class, 2);会发出两条sql
2、特殊情况下也有需要设置取一要取多的时候，例如树状结构,像论坛就不能取
3、不管设的是EAGER还是LAZY，手动都能取得数据，但是取数据的sql有点区别(了解)
4、测试各种单双向级联(all,merge,persist,remove)的update和delete，解释现象
5、注意merge，persist设置只在用merge和persist方法时有用
6、双向级联删除的时候默认会删掉相关两表的记录，可以设定关系为null或者写hql解决
7、通常在一的一方设置集合的级联操作,多的一方设置可能导致误操作（级联操作本质就是为了让关联对象保持状态一致）
8、inverse是配合级联操作的，通常代码设置好双向关联inverse就可以设置为true，避免多发update语句提高效率

注意包冲突:
部分annotation和load方法:和JavaEE5|JavaEE6包使用junit|main测试有冲突，可以使用JavaEE1.4
,不使用junit直接在web环境下使用没有冲突！

附加作业：树状结构
scott有emp表；empno ename mgr(empno)
写实体类映射emp表

*****************************************************************************************

四、数据查询语言 (和导航有关)

hibernate反向工程:myeclipse->project Capabilities->add Hibernate ...
1、添加hibernate包的时候选择myeclipse自带包
2、添加hibernate包的时候选择用户包
反向工程实现附加作业：树状结构

NativeSQL、HQL、QBC(Criteria)、QBE(Example)
HQL可用来做查询，更新和删除，但不能做添加，QBC、QBE只做查询

hql语句正确格式：(hql不可以用*)
from Husband | select name from Husband
select h from Husband h | select h.name from Husband h
错误格式：
select Husband from Husband | select Husband.name from Husband

Query query = sess.createQuery("from Husband where id<:id");
query.setParameter("id", 2); 用问号数字从0开始
链式：Query query = sess.createQuery("from Husband where id<:id").setParameter("id", 2);
封装条件对象：(注意这里只能使用命名参数不能使用？)
Qu q = new Qu();
q.setId(3);
Query query = sess.createQuery("from Husband h where id<:id").setProperties(q);
List<Husband> list = (List<Husband>)query.list();

其他实用重载设置参数方法：
setProperties(Map<String,Object>)
in查询或删除：
setParameterList("ids", ids(数组或集合));

分页：setMaxResults("每页显示几条")、setFirstResult("从这条记录开始但不包含这条")

返回唯一结果：uniqueResult() 必须是一条记录的结果集
long l = (Long)query.uniqueResult() (select count(0) from Wife) count返回long

from User与select id,name from User、select new Husband(id,name) from User区别：
返回类型不同：List<T> 和 List<Object[]>
内存管理不同：from出来的对象存在于session中，持久化状态，会与数据库同步
new Husband(id,name)：必须是注册的pojo对象，游离状态，不会脏检查

连表查询：
查询通常和导航一起用：通过关联关系自动导航查询，没有关联关系的用手动导航join
Join查询：from Wife w join fetch w.husband h(只能关联属性) //而不能写 join Husband h
自定义类型查询：select new 类名(有参构造)(po) from Husband，同样这样查询出来的对象也不会与数据库同步，即使你把po的id属性也查询出来

属性是否为空：is null
集合是否为空：is empty | h.wifes.size=0
函数：lower(h.name)
其他关键字：in exist(in的效率低于exist)

对于 "from 类名" 找不到映射的两种情况：
1、同一工程有不同包同名实体类
解决：
a、xml修改其中<mapping/> auto-import="false"
b、注解使用@Entity(name="全路径")

2、使用了@Entity(name="表名")
解决：使用@Table(name="表名")

注意：项目中必须使用三层架构，事务可以使用过滤器实现

*****************************************************************************************

五、
一、HQL高级

类级别懒加载：<class lazy="true" .../> @Proxy(lazy=true)
load()也会立即加载，同时还影响关联关系中的lazy，比如many-to-one设置lazy=proxy仍然会加载一的一方,而且是通过一条内联接语句查询出来，但是对于one-to-many不会加载

distinct|max|sum|avg|count|min查询：
select distinct 属性名 from 类名 or select distinct(属性名) from 类名

fetch和非fetch的区别：
返回List<Wife>:from Wife w [left] join fetch w.husband
返回List<Object[]>:from Wife w [left] join w.husband
(Object[0]==Wife,Object[1]==Husband)
迫切联接和非迫切联接返回类型不同,但都是持久化状态

联接查询：
指定属性的表连接不能使用fetch，返回数据没有状态
返回List<Object[]>:select w.id,w.name,h.id,h.name from Wife w join w.husband h

隐式内连接查询(笛卡儿积，没有映射关联关系的情况)：返回List<Object[]> 顺序同from后类顺序
from Husband h,Wife w where w.husband=h (不能h.wifes=w，集合和对象不能等)
from Husband h,Wife w where w.husband.hid=h.hid
from Husband h,Wife w where w.name=h.name
select w.wid,w.wname,w.husband.hname from wife w

二、性能优化：重点理解缓存问题
query.list()查询和query.iterate()查询的区别：

iterate:先取所有需要的id，然后用到哪个id就再根据id查询对应记录,第二次再iterate先看缓存是否存在，不存在才会才发sql，如果存在直接从缓存中取对象
list:二话不说直接取所有记录，即使同一事务中第二次list还会发sql去数据库取，不利用一级缓存(只会将查询结果放入缓存)

注意：<set...> 中设置了fetch="join"(联表查询)只对get()|load()|iterate()起作用(设置了join后,lazy属性将被忽略)，但hql的list()方法将仍使用lazy属性

三、命名查询
@NamedQueries({@NamedQuery(name="",query="")})
@NamedNativeQueries({@NamedNativeQuery(name="",query="")})
xml的可以支持：（hql和sql都支持）
和class节点同级，可以调用存储过程
<query name="hh">
<![CDATA[
from Husband h where h.hid=:id
]]>
</query>
<sql-query name="husbandById">
select * from husband where id=1
</sql-query>
List<Object[]> list = sess.getNamedQuery("husbandById").list();

<sql-query name="hh">
<return class="com.cssl.pojo.Husband"/>
select * from husband where id=1
</sql-query>
SQLQuery query = (SQLQuery)session.getNamedQuery("hh");
List<Husband> list = query.list();

session.createSQLQuery("insert into youtable (username,password,email) values(?,?,?)");
session.createSQLQuery("select * from husband").addEntity(Husband.class).list();
session.createSQLQuery("select h.*,w.* from husband h inner join wife w on h.id=w.h_id");
query.addEntity("h",Husband.class).addEntity("w", Wife.class)|addJoin("w", "h.wifes");
注意：返回的结果集List<Object[]>中对象顺序和addEntity一致(别名也要保证顺序)
Object[0]:Husband,Object[1]:Wife

*****************************************************************************************

六、QBC、QBE
QBC:
Criteria、DetachedCriteria和Example

Criteria criteria = sess.createCriteria(Husband.class).add(Restrictions.idEq(1));
Map map = new HashMap(); map.put("id", 1); map.put("name", "admin1");
criteria.add(Restrictions.allEq(map)).ilike("name","A",MatchMode.EXACT);

OR：criteria.add(Restrictions.or(criterion1,criterion2,...));
criteria.add(Restrictions.or(Restrictions.idEq(1),Restrictions.or(Restrictions.idEq(3))));
criteria.add(Restrictions.disjunction().add().add().add()); //多条件or

连接查询：
sess.createCriteria(Husband.class,"h").createCriteria("wifes",JoinType.INNER_JOIN);
sess.createCriteria(Husband.class,"h").createAlias("wifes","w")
.add(Restrictions.eq("h.name","..."))

排序：criteria.addOrder(Order.asc("id")).addOrder(Order.desc("age"));
分页查询：criteria.setFirstResult(2).setMaxResults(3);

投影查询：
org.hibernate.criterion.Projections是 Projection 的实例工厂。
通过调用 setProjection()应用投影到一个查询。
criteria.setProjection(Projections.rowCount());
//查询指定属性
criteria.setProjection(Property.forName("hname"));
//多属性或多个投影条件查询必须使用
Projections.projectionList().add(Projections.count("wname")).add(Projections.groupProperty("husband"));
或
Projections.projectionList().add(Property.forName("hname").count()).add(Property.forName("").group());

QBE: ID(主键)不参与条件比较
Husband h = new Husband(); (这里的Example对象必须是pojo,不同于hql的参数对象)
h.setName("");
criteria.add(Example.create(h));
联接查询：使用了like,excludeZeroes()忽略数字类型属性值为0的条件
Husband hh = (Husband)sess.createCriteria(Husband.class).add(Example.create(h).ignoreCase().enableLike().excludeZeroes()).createCriteria("wifes").uniqueResult();
QBE不能使用范围，因为set方法只能赋一个值
QBE用于动态查询语句(如网页上有很多条件可选)的情况下比拼接hql要简单很多

使用 examples 在关联对象上放置条件：（一定要分开添加条件）
1:Criteria criteria = session.createCriteria(Wife.class);
2:criteria.add(Example.create(w).excludeZeroes()).createCriteria("husband").add(Example.create(h).excludeZeroes());
如果wife表还需要继续连表必须分开写：
3:criteria.createCriteria("type").add(Example.create(t));
如果接着写表示为Husband关联的对象而非Wife关联的对象
criteria.add(Example.create(w).excludeZeroes())
.createCriteria("husband").add(Example.create(hx).excludeZeroes())
.createCriteria("type").add(Example.create(t).excludeZeroes());

criteria.createCriteria("B")
criteria.createCriteria("C");

QBE仅适合于给特定值的查询
Example e = Example.create(tExample).ignoreCase().enableLike();

QBC除了添加自己的条件，同时也能将例子对象e也当成条件添加进来
QBC可以添加给特定值的条件，也可添加给了一定范围的条件
session.createCriteria(Topic.class).add(Restrictions.gt("id", 2)).add(e);

*****************************************************************************************

七：Hibernate的一级、二级和查询缓存

hibernate 1+N问题：(面试题)
查询多的一方默认会把一的一方查询出来(注解:Eager xml:lazy="false")，而且是发N条sql的方式查询
1、将多的一方设FetchType.LAZY,用到一的一方的时候才发sql语句,只是延迟而已
2、使用hql的迫切左外联接查询（left join fetch），只发一条(xml可以设置fetch="join"只对get|load方法有用)
3、注解可以使用Criteria查询，即使用hql的左外联接查询，只发一条
4、@BatchSize(size=?) 取一的一方的时候发1+N/?条sql | xml中的class标签中设置batch-size="5" 只有fetch="select"有用

一级缓存：Session级别
二级缓存：SessionFactory级别的(经常被访问、改动不大、数量有限、不是很重要允许出现偶尔并发的数据)

20.2. The Second Level Cache
引入ehcache的jar包(注意版本要和hibernate一致，否则异常)
配置hibernate.cfg.xml:
hibernate4.0在hibernate.cfg.xml配置二级缓存和hibernate3.x有所不同,这里的测试用load测试，用query的话就要配置查询缓存

4.0配置如下：
<property name="cache.use_second_level_cache">true</property>
<property name="cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

3.x配置如下：
<property name="cache.use_second_level_cache">true</property>
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

复制etc下ehcache.xml
<defaultCache
maxElementsInMemory="10000" //最大元素
eternal="false" //永恒的
timeToIdleSeconds="1000" //发呆时间
timeToLiveSeconds="5000" //生存时间
overflowToDisk="true" //虚拟内存
/>

annotation:配置@Cache(usage=CacheConcurrencyStrategy.READ_WRITE)
|
<!— xml:
配置缓存,必须紧跟在class元素后面对缓存中的对象采用读写型的并发访问策略 -->
<cache usage="read-write"/>

<set name="products" table="products" cascade="all" inverse="true">

<cache usage="read-write"/>
......
</set>
也可以在hibernate.cfg.xml中配置哪些类的对象需要缓存：
<class-cache class="com.cssl.hibernate.Classes" usage="read-only" />
注意，这个<class-cache>标签必须放在<mapping>标签的后面！！

事务：ACID 原子性、持久性、隔离性、一致性

缓存同步策略:缓存同步策略决定了数据对象在缓存中的存取规则,我们必须为每个实体类指定相应的缓存同步策略.Hibernate中提供了4种不同的缓存同步策略:
1.read-only:只读.对于不会发生改变的数据可使用，缓存不更新，效率最高，事务隔离级别最低
2.nonstrict-read-write:缓存不定期更新，适用于变化频率低的数据
3.read-write:严格的读写缓存,实现了"read committed"事务隔离等级.缓存在数据变化时触发更新，适用于变化的数据
4.transactional:事务型缓存,必须运行在JTA事务环境中.缓存在数据变化时更新，并且支持事务，效率最低，事务隔离级别最高.

load()、get()、iterate()默认使用二级缓存，list()默认往二级缓存加数据，查询不用，除非打开查询缓存

查询缓存：
1、打开查询缓存要先打开二级缓存，然后代码还必须设置setCacheable(true)
2、只在查询语句一样、参数名一样、参数值一样的情况起作用

<property name="cache.use_query_cache">true</property>

sess.createQuery("from Husband h where h.hid<:id").setCacheable(true).list();
sess.createQuery("from Husband h where h.hid<:id").setCacheable(true).list();
查询缓存使用场合：
1、应用程序运行时经常使用的查询语句
2、很少对查询的数据进行增、删、改操作
如果查询结果中包含实体，查询缓存只会存放实体的OID，而属性查询会缓存所有数据值

其他性能优化：
1、大批量处理数据：在一个事务中处理大量数据
缺点：1、占用大量内存 2、执行大量的insert、delete或update操作频繁访问数据库
解决：
a、通过Session分批次执行，如每批次200条就flush()、clear()一次(commit()是提交，flush只是执行)
必须在hibernate.cfg.xml配置
<property name="jdbc.batch_size">200</property>
如果程序大于20也按20条提交
b、通过无状态StatelessSession，factory.openStatelessSession();
StatelessSession没有缓存，加载保存更新对象都没有状态，不与二级缓存交互，不进行任何级联操作
c、通过HQL或NativeSQL

2、集合过滤：多的一方数据庞大或需要对集合排序的情况，仍然要发sql语句
sess.createFilter(h.getWifes(), "where this.age>20 order by this.age");

3、使用容器中配置的数据源
由于hibernate默认的数据源不是专业的成熟的连接池产品，缺乏批量请求及容错能力
配置hibernate.cfg.xml:
<property name="connection.datasource">java:/comp/env/jdbc/MyDB</property>

从hibernate获取JDBC连接的方法：(调用存储过程)

4前的实现：
Session session=factory.openSession();
Connection con=session.connection();

4后替代方法：
Session session=factory.openSession();
session.dowork(new Work(){
@Override
public void execute(Connection conn) throws SQLException {
CallableStatement cs = connection.prepareCall("{call demo(?,?)}");
cs.setInt(1, 2);
cs.registerOutParameter(2, java.sql.Types.INTEGER);
cs.execute();
System.out.println(cs.getInt(2));
}
}
//DML也必须加事务

真正的高手并不是精通一切，而是精通在合适的场合使用合适的手段。

转载于:https://www.cnblogs.com/yuan211/p/8334661.html

weixin_38168918

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Hibernate 基础

写在框架学习之前：请务必建立手动查文档的能力，主动学习http://www.hibernate.org/downloads/一：1、导包：hibernate4+oracle->window->preferences->java->build path->user librariesbuild path->add libraries->user...
复制链接

扫一扫