zoukankan      html  css  js  c++  java
  • Hibernate3 多对多关系

    学习hibernate的笔迹第三篇,主要内容:多对多关系, 检索策略,HQL查询,QBC,事物管理,c3p0配置

     

    1.1.1  Hibernate的关联关系映射:(多对多)

    1.1.1.1     多对多的配置:

    步骤一创建实体和映射:

     1 Student:
     2 
     3 public class Student {
     4 
     5 private Integer sid;
     6 
     7 private String sname;
     8 
     9 // 学生选择多门课程.
    10 
    11 private Set<Course> courses = new HashSet<Course>();
    12 
    13 ...
    14 
    15 }
    Student
     1 public class Course {
     2 
     3 private Integer cid;
     4 
     5 private String cname;
     6 
     7 // 课程可以被多个学生选择:
     8 
     9 private Set<Student> students = new HashSet<Student>();
    10 
    11 ...
    12 
    13 }
    Course
     1 Student.hbm.xml
     2 <hibernate-mapping>
     3     <class name="cn.itcast.demo3.Student" table="student">
     4         <id name="sid" column="sid">
     5             <generator class="native"/>
     6         </id>
     7         <property name="sname" column="sname"/>
     8         <!-- 配置多对多关联关系 -->
     9         <set name="courses" table="stu_cour">
    10             <key column="sno"/>
    11             <many-to-many class="cn.itcast. demo3.Course" column="cno"/>
    12         </set>
    13     </class>
    14 </hibernate-mapping>
    Student.hbm.xml
     1 Course.hbm.xml
     2 <hibernate-mapping>
     3     <class name="cn.itcast. demo3.Course" table="course">
     4         <id name="cid" column="cid">
     5             <generator class="native"/>
     6         </id>
     7         
     8         <property name="cname" column="cname"/>
     9         
    10         <!-- 配置多对多关联关系映射 -->
    11         <set name="students" table="stu_cour">
    12             <key column="cno"/>
    13             <many-to-many class="cn.itcast. demo3.Student" column="sno"/>
    14         </set>
    15     </class>
    16 </hibernate-mapping>
    Course.hbm.xml

    2       抓取策略(优化)

    2.1   检索方式

    l  立即检索:立即查询,在执行查询语句时,立即查询所有的数据。

    l  延迟检索:延迟查询,在执行查询语句之后,在需要时在查询。(懒加载)

    2.2   检查策略

    l  类级别检索:当前的类的属性获取是否需要延迟。

    l  关联级别的检索:当前类 关联 另一个类是否需要延迟。

    2.3   类级别检索

    l  get:立即检索。get方法一执行,立即查询所有字段的数据。

    l  load:延迟检索。默认情况,load方法执行后,如果只使用OID的值不进行查询,如果要使用其他属性值将查询 。 Customer.hbm.xml  <class  lazy="true | false">

                  lazy 默认值true,表示延迟检索,如果设置false表示立即检索。

     

    @Test

       public void demo02() {

          //类级别

          Session session = factory.openSession();

          session.beginTransaction();

     

          //1立即

    //    Customer customer = (Customer) session.get(Customer.class, 1);

          //2延迟

          Customer customer = (Customer) session.load(Customer.class, 1);

         

         

         

          //打印

          System.out.println(customer.getCid());

          System.out.println(customer.getCname());

     

          session.getTransaction().commit();

          session.close();

       }

    2.4   关联级别检索

    2.4.1   一对多或多对多

    2.4.1.1         介绍

    l  容器<set> 提供两个属性:fetch、lazy

           fetch:确定使用sql格式

           lazy:关联对象是否延迟。

    l  fetch:join、select、subselect

           join:底层使用迫切左外连接

           select:使用多个select语句(默认值)

           subselect:使用子查询

    l  lazy:false、true、extra

           false:立即

           true:延迟(默认值)

           extra:极其懒惰

    一对多的时候:

    fetch         lazy       结论
    -----------------------------------------------------------------------------------------------------------
    select         true     默认值, 会在使用集合时加载,普通select语句
    select           false     立刻使用select语句加载集合数据
    select        extra     会在使用集合时加载,普通select语句,如果只是获得集合的长度,会发送Count语句查询长度.
    join         true     查询集合时使用表链接查询,会立刻加载集合数据
    join         false     查询集合时使用表链接查询,会立刻加载集合数据
    join         extra     查询集合时使用表链接查询,会立刻加载集合数据
    subselect     true     会在使用集合时加载,子查询语句
    subselect     false     会在查询用户时,立即使用子查询加载客户的订单数据
    subselect     extra     会在使用集合时加载,子查询语句,如果只是获得集合的长度,会发送Count语句查询长度.

    2.4.1.2         fetch="join"

    l  fetch="join" ,lazy无效。底层使用迫切左外连接,使用一条select将所有内容全部查询。

     

    @Test

       public void demo03() {

          //关联级别:一对多,

          // * Customer.hbm.xml  <set fetch="join">

          // *** select语句使用左外连接,一次性查询所有

          Session session = factory.openSession();

          session.beginTransaction();

     

          //1 查询客户

          Customer customer = (Customer) session.get(Customer.class, 1);

          System.out.println(customer.getCname());

         

          //2 查询客户订单数

          Set<Order> orderSet = customer.getOrderSet();

          System.out.println(orderSet.size());

         

          //3 查询客户订单详情

          for (Order order : orderSet) {

             System.out.println(order);

          }

         

     

          session.getTransaction().commit();

          session.close();

       }

    2.4.1.3         fetch="select"

      当前对象   和   关联对象 使用多条select语句查询。

      lazy="false" , 立即,先查询客户select,立即查询订单select

      lazy="true",延迟,先查询客户select,需要订单时,再查询订单select

      lazy="extra",极其懒惰(延迟),先查询客户select, 如果只需要订单数,使用聚合函数(不查询详情)

     

    2.4.1.4         fetch="subselect"

      将使用子查询。注意:必须使用Query否则看不到效果。

      lazy= 同上

    @Test

       public void demo04() {

          //关联级别:一对多,

          // 演示3:* Customer.hbm.xml  <set fetch="subselect">

          Session session = factory.openSession();

          session.beginTransaction();

     

          //1 查询客户

          List<Customer> allCustomer = session.createQuery("from Customer").list();

          Customer customer = allCustomer.get(0);

          System.out.println(customer.getCname());

         

          //2 查询客户订单数

          Set<Order> orderSet = customer.getOrderSet();

          System.out.println(orderSet.size());

         

          //3 查询客户订单详情

          for (Order order : orderSet) {

             System.out.println(order);

          }

         

     

          session.getTransaction().commit();

          session.close();

       }

     

    2.4.2   多对一

    2.4.2.1         介绍

      <many-to-one fetch="" lazy="">  (<one-to-one>)

      fetch取值:join、select

               join:底层使用迫切左外连接

               select:多条select语句

      lazy取值:false、proxy、no-proxy

           false:立即

           proxy:采用关联对象 类级别检索的策略。

                    订单 关联 客户 (多对一)

                    订单 立即获得 客户,需要在客户Customer.hbm.xml <class lazy="false">

                    订单 延迟获得 客户,需要在客户Customer.hbm.xml <class lazy="true">

           no-proxy 不研究

    fetch         lazy       结果
    ---------------------------------------------------
    select          false      加载订单时,立即加载客户数据.普通select语句加载客户.
    select          proxy     类加载策略为:lazy=false 同上
                                    lazy=true 加载订单时,先不加载客户数据.使用客户数据时才加载
    join           false     使用表链接查询订单以及对应客户信息.lazy属性无效
    join           proxy       使用表链接查询订单以及对应客户信息.lazy属性无效

    2.4.2.2         fetch="join"

      fecth="join" select语句使用左外连接,此时lazy无效。

     

    @Test

       public void demo05() {

          //关联级别:多对一,

          // 演示1:* Order.hbm.xml  <set fetch="join">  lazy无效

          // * 注意:检查Customer.hbm.xml 和 Order.hbm.xml 没有额外的配置

          Session session = factory.openSession();

          session.beginTransaction();

     

          //1 查询订单

          Order order = (Order) session.get(Order.class, 1);

          System.out.println(order.getPrice());

         

          //2 查询订单客户信息

          Customer customer = order.getCustomer();

          System.out.println(customer.getCname());

         

     

          session.getTransaction().commit();

          session.close();

       }

    2.4.2.3         fetch="select"l 

      将采用多条select语句,lazy="proxy"是否延迟,取决关联对象 类级别检索策略。

      lazy="false"

     

      lazy="proxy"

     

    2.5   批量查询

      当客户 关联查询 订单,给每一个客户生产一个select语句查询订单。批量查询使用in语句减少查询订单语句个数。

           默认:select * from t_order where customer_id = ?

           批量:select * from t_order where customer_id in (?,?,?,?)

      <set batch-size="5"> 5表示括号中?个数。

     

    @Test

       public void demo06() {

          //批量查询

          Session session = factory.openSession();

          session.beginTransaction();

         

          //1 查询所有客户

          List<Customer> allCustomer = session.createQuery("from Customer").list();

         

          //2遍历

          for (Customer customer : allCustomer) {

             System.out.println(customer.getCname());

             System.out.println(customer.getOrderSet().size());

          }

          

          session.getTransaction().commit();

          session.close();

       }

    2.6   检索总结

    检索策略

    优点

    缺点

    优先考虑使用的场合

    立即检索

    对应用程序完全透明,不管对象处于持久化状态还是游离状态,应用程序都可以从一个对象导航到关联的对象

    (1)select语句多

    (2)可能会加载应用程序不需要访问的对象,浪费许多内存空间。

    (1)类级别

    (2)应用程序需要立即访问的对象

    (3)使用了二级缓存

    延迟检索

    由应用程序决定需要加载哪些对象,可以避免执行多余的select语句,以及避免加载应用程序不需要访问的对象。因此能提高检索性能,并节省内存空间。

    应用程序如果希望访问游离状态的代理类实例,必须保证她在持久化状态时已经被初始化。

    (1)一对多或者多对多关联

    (2)应用程序不需要立即访问或者根本不会访问的对象

                  

    表连接检索

    (1)对应用程序完全透明,不管对象处于持久化状态还是游离状态,都可从一个对象导航到另一个对象。

    (2)使用了外连接,select语句少

    (1)可能会加载应用程序不需要访问的对象,浪费内存。

    (2)复杂的数据库表连接也会影响检索性能。

    (1)多对一或一对一关联

    (2)需要立即访问的对象

    (3)数据库有良好的表连接性能。

    Customer  Get(int id)

           Return Session.load(Customer.class,id);

    1. layz=false
    2. 在Service层获得在页面要上要用到的属性=> 在Service层中确保数据已经

    3       查询方式总结

    1.通过OID检索(查询)

           get()立即、如果没有数据返回null

           load()延迟,如果没有数据抛异常。

    2.导航对象图检索方式:关联查询

           customer.getOrderSet()

           user.getPost().getDepartment().getDepName();

    3.原始sql语句

           SQLQuery sqlQuery = session.createSQLQuery("sql 语句")   --->表,表字段(列)

                  sqlQuery.list() 查询所有

                  sqlQuery.uniqueResult() 查询一个

    4.HQL,hibernate query language hibernate 查询语言【1】

           Query query = session.createQuery("hql语句")  --> 对象,对象属性

    5.QBC,query by criteria 纯面对对象查询语言【2】

    4       HQL【掌握】

    4.1   介绍

     

    4.2   查询所有客户

    @Test

       public void demo01(){

          //1 查询所有

          Session session = factory.openSession();

          session.beginTransaction();

         

          //1  使用简单类名 , 存在自动导包

          // * Customer.hbm.xml <hibernate-mapping auto-import="true">

    //    Query query = session.createQuery("from Customer");

          //2 使用全限定类名

          Query query = session.createQuery("from com.itheima.a_init.Customer");

         

          List<Customer> allCustomer = query.list();

          for (Customer customer : allCustomer) {

             System.out.println(customer);

          }

         

          session.getTransaction().commit();

          session.close();

       }

    4.3   选择查询

    @Test

       public void demo02(){

          //2 简单条件查询

          Session session = factory.openSession();

          session.beginTransaction();

         

         

          //1 指定数据,cid OID名称

    //    Query query = session.createQuery("from Customer where cid = 1");

          //2 如果使用id,也可以(了解)

    //    Query query = session.createQuery("from Customer where id = 1");

          //3 对象别名 ,格式: 类 [as] 别名

    //    Query query = session.createQuery("from Customer as c where c.cid = 1");

          //4 查询所有项,mysql--> select * from...

          Query query = session.createQuery("select c from Customer as c where c.cid = 1");

         

          Customer customer = (Customer) query.uniqueResult();

          System.out.println(customer);

         

          session.getTransaction().commit();

          session.close();

       }

    4.4   投影查询(部分)

    @Test

       public void demo04(){

          //4 投影

          Session session = factory.openSession();

          session.beginTransaction();

         

          //1 默认

          //如果单列 ,select c.cname from,需要List<Object>

          //如果多列,select c.cid,c.cname from ,需要List<Object[]>  ,list存放每行,Object[]多列

    //    Query query = session.createQuery("select c.cid,c.cname from Customer c");

          //2 将查询部分数据,设置Customer对象中

          // * 格式:new Customer(c.cid,c.cname)

          // * 注意:Customer必须提供相应的构造方法。

          // * 如果投影使用oid,结果脱管态对象。

          Query query = session.createQuery("select new Customer(c.cid,c.cname) from Customer c");

         

          List<Customer> allCustomer = query.list();

          for (Customer customer : allCustomer) {

             System.out.println(customer.getCid() + " : " + customer.getOrderSet().size());

          }

         

          session.getTransaction().commit();

          session.close();

       }

    4.5   排序

    @Test

       public void demo03(){

          //3排序 ,mysql--> select... order by 字段  [asc]|desc ,....

          Session session = factory.openSession();

          session.beginTransaction();

         

          Query query = session.createQuery("from Customer order by cid desc");

         

          List<Customer> allCustomer = query.list();

          for (Customer customer : allCustomer) {

             System.out.println(customer.getCid());

          }

         

          session.getTransaction().commit();

          session.close();

       }

    4.6   分页

    @Test

       public void demo05(){

          //分页

          Session session = factory.openSession();

          session.beginTransaction();

         

          Query query = session.createQuery("from Customer");

          // * 开始索引 , startIndex 算法: startIndex = (pageNum - 1) * pageSize;

          // *** pageNum 当前页(之前的 pageCode)

          query.setFirstResult(0);

          // * 每页显示个数 , pageSize

          query.setMaxResults(2);

         

          List<Customer> allCustomer = query.list();

          for (Customer customer : allCustomer) {

             System.out.println(customer.getCid());

          }

         

          session.getTransaction().commit();

          session.close();

       }

    4.7   绑定参数

    @Test

       public void demo06(){

          /* 6 绑定参数

           * 方式1:占位符,使用? 在hql语句替换具体参数

           *    设置参数 query.setXxx(int , object)

           *        参数1:?位置,从0开始。

           *        参数2:实际参数

           *    例如:String --> query.setString(int,String)

           * 方式2:别名 , 格式 “属性= :别名 ”

           *    设置参数 query.setXxx(String,object)

           *        参数1:别名

           *        参数2:实际参数

           *    例如:Integer --> query.setInteger(String,Integer)

           * 提供公共设置方法

           * setParameter(int|string , Object)

           */

          Session session = factory.openSession();

          session.beginTransaction();

         

          Integer cid = 1;

         

          //方式1

    //    Query query = session.createQuery("from Customer where cid = ?");

    //    query.setInteger(0, cid);

          //方式2

          Query query = session.createQuery("from Customer where cid = :xxx");

    //    query.setInteger("xxx", cid);

          query.setParameter("xxx", cid);

         

          Customer customer = (Customer) query.uniqueResult();

          System.out.println(customer);

         

          session.getTransaction().commit();

          session.close();

       }

    4.8   聚合函数和分组

    @Test

       public void demo07(){

          /* 7  聚合函数

           */

          Session session = factory.openSession();

          session.beginTransaction();

         

          //1

    //    Query query = session.createQuery("select count(*) from Customer");

          //2 别名

    //    Query query = session.createQuery("select count(c) from Customer c");

          //3 oid

          Query query = session.createQuery("select count(cid) from Customer");

         

          Long numLong = (Long) query.uniqueResult();

          int num = numLong.intValue();

         

          System.out.println(num);

         

         

          session.getTransaction().commit();

          session.close();

       }

    4.9   连接查询

     

    1.交叉连接 ,等效 sql 笛卡尔积

    2.隐式内连接,等效 sql 隐式内连接

    3.内连接,等效sql内连接

    4.迫切内连接,hibernate底层使用 内连接。

    5.左外连接,等效sql左外连接

    6.迫切左外连接,hibernate底层使用 左外连接

    7.右外连接,等效sql右外连接

    内连接和迫切内连接?

    左外连接和迫切左外连接?

    @Test

       public void demo08(){

          /* 8 链接查询 : 左外连接和迫切左外连接?

           * * 左外连接 , left outer join

           *    底层使用sql的左外连接,hibernate进行数据自动封装,将一条记录,封装给两个对象(Customer,Order)

           *    将两个对象添加到一个对象数组中Object[Customer,Order]

           * * 迫切左外链接 left outer join fetch

           *    底层使用sql的左外连接,hibernate将一条记录封装给Customer,讲order数据封装Order,并将order关联到Customer

           *        customer.getOrderSet().add(order)

           *    默认查询的数据重复

           */

          Session session = factory.openSession();

          session.beginTransaction();

         

          //左外连接

    //    List list = session.createQuery("from Customer c left outer join c.orderSet ").list();

          //迫切左外链接 (默认数据重复)

    //    List list = session.createQuery("from Customer c left outer join fetch c.orderSet ").list();

          //迫切左外链接 (去重复)

          List list = session.createQuery("select distinct c from Customer c left outer join fetch c.orderSet ").list();

         

         

          session.getTransaction().commit();

          session.close();

       }

    4.10     命名查询

    l  思想:将HQL从java源码中,提取到配置文件中。

    l  分类:全局、布局

    l  配置

           全局:*.hbm.xml   <class></class><query name="名称">HQL语句

                 

           局部: <class name="" table=""><id><property> <query name="">HQL</class>

                 

    l  获得

           全局:

                  session.getNamedQuery("queryName")

           局部:

                  session.getNamedQuery("className.queryName")  需要使用类的全限定名称

     

    @Test

       public void demo09(){

          /* 9 命名查询

           */

          Session session = factory.openSession();

          session.beginTransaction();

         

          //全局

          //List list = session.getNamedQuery("findAll").list();

          //局部

          List list = session.getNamedQuery("com.itheima.a_init.Customer.findAll").list();

         

          System.out.println(list.size());

         

          session.getTransaction().commit();

          session.close();

       }

    5       QBC【了解】

    5.1.1.1     QBC查询:

    QBC:Query By Criteria条件查询.面向对象的查询的方式.

    5.1.1.2     QBC简单的查询:

         // 简单查询:

         List<Customer> list = session.createCriteria(Customer.class).list();

         for (Customer customer : list) {

             System.out.println(customer);

         }

    5.1.1.3     QBC分页的查询:

         Criteria criteria = session.createCriteria(Order.class);

         criteria.setFirstResult(10);

         criteria.setMaxResults(10);

         List<Order> list = criteria.list();

    5.1.1.4     QBC排序查询:

         Criteria criteria = session.createCriteria(Customer.class);

     //   criteria.addOrder(org.hibernate.criterion.Order.asc("age"));

         criteria.addOrder(org.hibernate.criterion.Order.desc("age"));

         List<Customer> list = criteria.list();

    5.1.1.5     QBC条件查询:

         // 按名称查询:

         /*Criteria criteria = session.createCriteria(Customer.class);

         criteria.add(Restrictions.eq("cname", "tom"));

         List<Customer> list = criteria.list();*/

        

         // 模糊查询;

         /*Criteria criteria = session.createCriteria(Customer.class);

         criteria.add(Restrictions.like("cname", "t%"));

         List<Customer> list = criteria.list();*/

        

         // 条件并列查询

         Criteria criteria = session.createCriteria(Customer.class);

         criteria.add(Restrictions.like("cname", "t%"));

         criteria.add(Restrictions.ge("age", 35));

         List<Customer> list = criteria.list();

     

     

    5.1.1.6         离线查询(了解)

    l  DetachedCriteria 离线查询对象,不需要使用Session就可以拼凑查询条件。一般使用在web层或service层拼凑。将此对象传递给dao层,此时将与session进行绑定执行查询。

    l  离线查询条件与QBC一样的。

     

    @Test

       public void demo10(){

          /* 10 离线查询

           */

         

          //web & service

          DetachedCriteria detachedCriteria = DetachedCriteria.forClass(Customer.class);

          detachedCriteria.add(Restrictions.eq("cid", 1));

         

          //---------------dao

         

          Session session = factory.openSession();

          session.beginTransaction();

         

          // 离线Criteria 与session绑定

          Criteria criteria = detachedCriteria.getExecutableCriteria(session);

          List<Customer> allCustomer = criteria.list();

          System.out.println(allCustomer.size());

         

          session.getTransaction().commit();

          session.close();

       }

    6       常见配置

    6.1   整合c3p0(连接池) (了解)

    l  整合c3p0

          

           步骤一:导入c3p0 jar包

                 

           步骤二:hibernate.cfg.xml 配置

                  hibernate.connection.provider_class     org.hibernate.connection.C3P0ConnectionProvider

                 

    l  c3p0具体配置参数

           ###########################

    ### C3P0 Connection Pool###

    ###########################

    #hibernate.c3p0.max_size 2

    #hibernate.c3p0.min_size 2

    #hibernate.c3p0.timeout 5000

    #hibernate.c3p0.max_statements 100

    #hibernate.c3p0.idle_test_period 3000

    #hibernate.c3p0.acquire_increment 2

    #hibernate.c3p0.validate false

    6.2   事务

    6.2.1   回顾

    l  事务:一组业务操作,要么全部成功,要么全部不成功。

    l  特性:ACID

           原子性:整体

           一致性:数据

           隔离性:并发

           持久性:结果

    l  隔离问题:

           脏读:一个事务读到另一个事务未提交的内容

           不可重复读:一个事务读到另一个事务已提交的内容(insert)

           虚读(幻读):一个事务读到另一个事务已提交的内容(update)

    l  隔离级别--解决问题

           read uncommittd,读未提交。存在3个问题。

           read committed,读已提交。解决:脏读。存在2个问题。

           repeatable read ,可重复读。解决:脏读、不可重复读。存在1个问题。

           serializable,串行化。单事务。没有问题。

          

    6.2.2   hibernate设置隔离级别

    l  在hibernate.cfg.xml 配置

           hibernate.connection.isolation     4

     

    6.2.3   lost update 丢失更新

     

    l  悲观锁: 默认认为一定会发送别人要修改我使用的数据. 那我就可以为我读取的数据加锁.

          读锁/共享锁 => 读锁可被其他线程所共享,如果是读取的话大家都可以用这把锁读到数据.
              select * from table lock in share mode(读锁、共享锁)

          写锁/排他锁 => 写锁不能共享,只要有人为数据加入了写锁,其他人就不能为数据加任何锁.
              select * from table for update (写锁、排它锁)

          

    l  乐观锁:丢失更新肯定不会发生

           在表中提供一个字段(版本字段),用于标识记录。如果版本不一致,不允许操作。

          

    6.2.4   hibernate处理丢失更新

    l  悲观锁:写锁

          

    @Test

       public void demo01(){

          //1 查询所有

          Session session = factory.openSession();

          session.beginTransaction();

         

          Customer customer = (Customer) session.get(Customer.class, 1, LockOptions.UPGRADE);

          System.out.println(customer);

         

          session.getTransaction().commit();

          session.close();

       }

    l  乐观锁:

           在PO对象(javabean)提供字段,表示版本字段。一般Integer

           在*.hbm.xml 文件配置 <version name="...">

    步骤一:

          

    步骤二:

          

          

    步骤三:测试

    @Test

       public void demo02(){

          //1 查询所有

          Session session = factory.openSession();

          session.beginTransaction();

         

    //    Order order = new Order();

    //    order.setPrice(998d);

    //    session.save(order);

         

          Order order = (Order) session.get(Order.class, 32);

          order.setPrice(889d);

         

         

          session.getTransaction().commit();

          session.close();

       }

  • 相关阅读:
    20145337实验五Java网络编程及安全
    20145337 《Java程序设计》第10周学习总结
    20145337实验四Android开发基础
    20145337 《Java程序设计》第九周学习总结
    20145337实验三实验报告——敏捷开发与XP实践
    20145337《Java程序设计》第八周学习总结
    20145337《JAVA程序设计》第七周学习总结
    JAVA面向对象程序设计——实验报告
    20145337 《Java程序设计》第六周学习总结
    20145336张子扬 《信息安全系统设计基础》第6周学习总结(一)
  • 原文地址:https://www.cnblogs.com/soficircle/p/7103870.html
Copyright © 2011-2022 走看看