七、MyBatis多表查询1 一对一查询（多对一）

56 阅读 0 评论 37 点赞

我是靠谱客的博主威武超短裙，最近开发中收集的这篇文章主要介绍七、MyBatis多表查询1 一对一查询（多对一），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

1 一对一查询（多对一）

需求：查询所有账户信息，关联查询下单用户信息。

注意：因为一个账户信息只能供某个用户使用，所以从查询账户信息出发关联查询用户信息为一对一查询。如果从用户信息出发查询用户下的账户信息则为一对多查询，因为一个用户可以有多个账户。

补充 account 、role 、user_role 3张新数据表：

CREATE TABLE `account` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `UID` int(11) default NULL COMMENT '用户编号',
  `MONEY` double default NULL COMMENT '金额',
  PRIMARY KEY  (`ID`),
  KEY `FK_Reference_8` (`UID`),
  CONSTRAINT `FK_Reference_8` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `account`(`ID`,`UID`,`MONEY`) values (1,46,1000),(2,45,1000),(3,46,2000);


CREATE TABLE `role` (
  `ID` int(11) NOT NULL COMMENT '编号',
  `ROLE_NAME` varchar(30) default NULL COMMENT '角色名称',
  `ROLE_DESC` varchar(60) default NULL COMMENT '角色描述',
  PRIMARY KEY  (`ID`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `role`(`ID`,`ROLE_NAME`,`ROLE_DESC`) values (1,'院长','管理整个学院'),(2,'总裁','管理整个公司'),(3,'校长','管理整个学校');


CREATE TABLE `user_role` (
  `UID` int(11) NOT NULL COMMENT '用户编号',
  `RID` int(11) NOT NULL COMMENT '角色编号',
  PRIMARY KEY  (`UID`,`RID`),
  KEY `FK_Reference_10` (`RID`),
  CONSTRAINT `FK_Reference_10` FOREIGN KEY (`RID`) REFERENCES `role` (`ID`),
  CONSTRAINT `FK_Reference_9` FOREIGN KEY (`UID`) REFERENCES `user` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user_role`(`UID`,`RID`) values (41,1),(45,1),(41,2);

1.1 方式一

1.1.1 定义账户信息的实体类

/**
  * <p>Title: Account</p>
  * <p>Description: 账户的实体类</p>
  */
public class Account implements Serializable {
	private Integer id;
	private Integer uid;
	private double money;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public Integer getUid() {
		return uid;
	}
	public void setUid(Integer uid) {
		this.uid = uid;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
	@Override
	public String toString() {
		return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
	}
}

1.1.2 编写SQL语句

实现查询账户信息时，也要查询账户所对应的用户信息。

SELECT 
  account.*, 
  user.username, 
  user.address 
FROM 
  account, 
  user 
WHERE 
  account.uid = user.id

在MySQL中测试的查询结果如下：
在这里插入图片描述

1.1.3 定义AccountUser类

为了能够封装上面SQL语句的查询结果，定义AccountUser类中既要包含用户信息也要包含账户信息，所以我们要在定义AccountUser类时可以继承Account类。

/**
  * <p>Title: AccountUser</p>
  * <p>Description: 它是Account的子类</p>
  */
public class AccountUser extends Account implements Serializable {
	private String username;
	private String address;
	
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
    public String toString() {
		return super.toString() + " AccountUser [username=" + username + ", address=" + address + "]";
	}
}

1.1.4 定义账户的持久层Dao接口

/**
  * <p>Title: IAccountDao</p>
  * <p>Description: 账户的持久层接口</p>
  */
 public interface IAccountDao {
 	/**
 	  * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
 	  * @return
 	  */
 	List<AccountUser> findAll();
 }

1.1.5 定义AccountDao.xml文件中的查询配置信息

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IAccountDao">
    <!-- 配置查询所有操作-->
    <select id="findAll" resultType="accountuser">
    	select a.*,u.username,u.address from account a,user u where a.uid=u.id;
    </select>
</mapper>

注意：因为上面查询的结果中包含了账户信息同时还包含了用户信息，所以我们的返回值类型returnType的值设置为AccountUser类型，这样就可以接收账户信息和用户信息了。

1.1.6 创建AccountTest测试类

/**
  * <p>Title: MybastisCRUDTest</p>
  * <p>Description: 一对多账户的操作</p>
  */
public class AccountTest {
	private InputStream in ;
	private SqlSessionFactory factory;
	private SqlSession session;
	private IAccountDao accountDao;

	@Before//在测试方法执行之前执行
	public void init()throws Exception {
		//1.读取配置文件 
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2.创建构建者对象 
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		//3.创建SqlSession工厂对象 
		factory = builder.build(in);
		//4.创建SqlSession对象 
		session = factory.openSession();
		//5.创建Dao的代理对象 
		accountDao = session.getMapper(IAccountDao.class);
	}

	@Test
    public void testFindAll() {
		//6.执行操作 
		List<AccountUser> accountusers = accountDao.findAll();
		for (AccountUser au : accountusers) {
			System.out.println(au);
		}
	}
	
	@After//在测试方法执行完成之后执行
	public void destroy() throws Exception{
		session.commit();
		//7.释放资源 
		session.close();
		in.close();
	}
}

1.1.7 小结

定义专门的pojo类作为输出类型，其中定义了sql查询结果集所有的字段。此方法较为简单，企业中使用普遍。

1.2 方式二

定义专门的 resultMap 用于映射一对一查询结果。
通过面向对象的（has a）关系可以得知，我们可以在Account类中加入一个User类的对象来代表这个账户是哪个用户的。

1.2.1 修改Account类

在Account类中加入User类的对象作为Account类的一个属性。

/**
  * <p>Title: Account</p>
  * <p>Description: 账户的实体类</p>
  */
public class Account implements Serializable {
	private Integer id;
	private Integer uid;
	private double money;
	
    //从表实体应该包含一个主表实体的对象引用
	private User user;
	
	public User getUser() {
		return user;
	}
	public void setUser(User user) {
		this.user = user;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public Integer getUid() {
		return uid;
	}
	public void setUid(Integer uid) {
		this.uid = uid;
	}
	public double getMoney() {
		return money;
	}
	public void setMoney(double money) {
		this.money = money;
	}
	@Override
    public String toString() {
		return "Account [id=" + id + ", uid=" + uid + ", money=" + money + "]";
	}
}

1.2.2 修改AccountDao接口中的方法

/**
  * <p>Title: IAccountDao</p>
  * <p>Description: 账户的持久层接口</p>
  */
public interface IAccountDao {
	/**																																											
	  * 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
	  * @return
	  */
	List<Account> findAll();
}

注意：第二种方式，将返回值改为了Account类型。因为Account类中包含了一个User类的对象，它可以封装账户所对应的用户信息。

1.2.3 重新定义AccountDao.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IAccountDao">
    <!-- 建立对应关系 -->
    <resultMap type="account" id="accountMap">
        <id column="aid" property="id"/>
        <result column="uid" property="uid"/>
        <result column="money" property="money"/>
        <!-- association用于指定一方，为一个类（User） -->
        <association property="user" javaType="user">
            <id column="id" property="id"/>
            <result column="username" property="username"/>
            <result column="sex" property="sex"/>
            <result column="birthday" property="birthday"/>
            <result column="address" property="address"/>
        </association>
    </resultMap>
    <select id="findAll" resultMap="accountMap">
    	select u.*,a.id as aid,a.uid,a.money from account a,user u where a.uid=u.id;
    </select>
</mapper>

1.2.4 在AccountTest类中加入测试方法

@Test
public void testFindAll() {
	List<Account> accounts = accountDao.findAll();
	for (Account au : accounts) {
		System.out.println(au);
		System.out.println(au.getUser());
	}
}

2 一对多查询

用户为User 表，账户为Account表。一个用户（User）可以有多个账户（Account）。具体关系如下：
在这里插入图片描述
需求：查询所有用户信息及用户关联的账户信息。
分析：用户信息和他的账户信息为一对多关系，并且查询过程中如果用户没有账户信息，此时也要将用户信息查询出来，我们想到了左外连接查询比较合适。

2.1 编写SQL语句

SELECT 
  u.*,
  a.id as aid ,a.uid,a.money
FROM 
  user u 
  LEFT JOIN account acc ON u.id = acc.uid

测试该SQL语句在MySQL客户端工具的查询结果如下：
在这里插入图片描述

2.2 User类加入List<Account>

/**
  * <p>Title: User</p>
  * <p>Description: 用户的实体类</p>
  */
public class User implements Serializable {
	private Integer id;
	private String username;
	private Date birthday;
	private String sex;
	private String address;

	//一对多关系映射：主表实体应该包含从表实体的集合引用
	private List<Account> accounts;
	
	public List<Account> getAccounts() {
		return accounts;
	}
	public void setAccounts(List<Account> accounts) {
		this.accounts = accounts;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getAddress() {
		return address;
	}
	public void setAddress(String address) {
		this.address = address;
	}
	@Override
	public String toString() {
		return "User [id=" + id + ", username=" + username + ", birthday=" + birthday + ", sex=" + sex + ", address=" + address + "]";
	}
}

2.3 用户持久层Dao接口中加入查询方法

/**
  * 查询所有用户，同时获取出每个用户下的所有账户信息
  * @return
  */
List<User> findAll();

2.4 用户持久层Dao映射文件配置

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IUserDao">
    <resultMap type="user" id="userMap">
        <id column="id" property="id"></id>
        <result column="username" property="username"/>
        <result column="address" property="address"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <!-- collection是用于指定多方，为一个集合（List<Account>） -->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"/>
            <result column="uid" property="uid"/>
            <result column="money" property="money"/>
        </collection>
    </resultMap>
    <!-- 配置查询所有操作 -->
    <select id="findAll" resultMap="userMap">
    	select u.*,a.id as aid ,a.uid,a.money from user u left outer join account a on u.id=a.uid
    </select>
</mapper>

collection ：部分定义了用户关联的账户信息。表示关联查询结果集。
property="accounts" ：关联查询的结果集存储在User对象的上哪个属性。
ofType="account" ：指定关联查询的结果集中的对象类型即List中的对象类型。此处可以使用别名，也可以使用全限定名。

2.5 测试方法

/**
  * <p>Title: MybastisCRUDTest</p>
  * <p>Description: 一对多的操作</p>
  */
public class UserTest {
	private InputStream in ;
	private SqlSessionFactory factory;
	private SqlSession session;
	private IUserDao userDao;

	@Before//在测试方法执行之前执行
	public void init()throws Exception {
		//1.读取配置文件
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2.创建构建者对象
		SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
		//3.创建SqlSession 工厂对象
		factory = builder.build(in);
		//4.创建SqlSession 对象
		session = factory.openSession();
		//5.创建Dao 的代理对象
		userDao = session.getMapper(IUserDao.class);
	}

	@Test
    public void testFindAll() {
		//6.执行操作 
		List<User> users = userDao.findAll();
		for (User user : users) {
			System.out.println("-------每个用户的内容---------");
			System.out.println(user);
			System.out.println(user.getAccounts());
		}
	}
	
	@After//在测试方法执行完成之后执行
	public void destroy() throws Exception{
		session.commit();
		//7.释放资源
		session.close();
		in.close();
	}
}

3 多对多查询

3.1 实现Role到User多对多

通过前面的学习，我们使用MyBatis实现一对多关系的维护。多对多关系其实我们看成是双向的一对多关系。

3.1.1 用户与角色的关系模型

用户与角色的多对多关系模型如下：
在这里插入图片描述
在MySQL数据库中添加角色表，用户角色的中间表。
角色表：

用户角色中间表：

3.1.2 业务要求及实现SQL

需求：实现查询所有对象并且加载它所分配的用户信息。
分析：查询角色我们需要用到Role表，但角色分配的用户的信息我们并不能直接找到用户信息，而是要通过中间表(USER_ROLE表)才能关联到用户信息。下面是实现的SQL语句：

SELECT
	r.*,
    u.id uid,
    u.username username,
    u.birthday birthday,
    u.sex sex,
    u.address address
FROM ROLE r
INNER JOIN USER_ROLE ur ON (r.id = ur.rid)
INNER JOIN USER u ON (ur.uid = u.id);

3.1.3 编写角色实体类

public class Role implements Serializable {
	private Integer roleId;
	private String roleName;
	private String roleDesc;
	//多对多的关系映射：一个角色可以赋予多个用户 
	private List<User> users;
	
	public List<User> getUsers() {
		return users;
	}
	public void setUsers(List<User> users) {
		this.users = users;
	}
	public Integer getRoleId() {
		return roleId;
	}
	public void setRoleId(Integer roleId) {
		this.roleId = roleId;
	}
	public String getRoleName() {
		return roleName;
	}
	public void setRoleName(String roleName) {
		this.roleName = roleName;
	}
	public String getRoleDesc() {
		return roleDesc;
	}
	public void setRoleDesc(String roleDesc) {
		this.roleDesc = roleDesc;
	}
	@Override
	public String toString() {
		return "Role{roleId=" + roleId +
				", roleName='" + roleName + ''' +
				", roleDesc='" + roleDesc + ''' + '}';
    } 
}

3.1.4 编写Role持久层接口

public interface IRoleDao {
	/**
	  * 查询所有角色
	  * @return
	  */
	List<Role> findAll();
}

3.1.5 编写映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.IRoleDao">
    <!--定义role表的ResultMap-->
    <resultMap id="roleMap" type="role">
        <id property="roleId" column="id"></id>
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id column="uid" property="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
        </collection>
    </resultMap>
    <!--查询所有-->
    <select id="findAll" resultMap="roleMap">
    	select u.*,r.id as rid,r.role_name,r.role_desc from role r left outer join user_role ur on r.id = ur.rid left outer join user u on u.id = ur.uid
    </select>
</mapper>

3.1.6 编写测试类

public class RoleTest {
	private InputStream in;
	private SqlSession sqlSession;
	private IRoleDao roleDao;
	
	@Before//用于在测试方法执行之前执行
	public void init()throws Exception{
		//1.读取配置文件，生成字节输入流
		in = Resources.getResourceAsStream("SqlMapConfig.xml");
		//2.获取SqlSessionFactory 
		SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(in);
		//3.获取SqlSession对象 
		sqlSession = factory.openSession(true);
		//4.获取dao的代理对象 
		roleDao = sqlSession.getMapper(IRoleDao.class);
	}
	
	@After//用于在测试方法执行之后执行
	public void destroy()throws Exception{
		//提交事务 
		// sqlSession.commit(); 
		//6.释放资源 
		sqlSession.close();
		in.close();
	}
	
	@Test//测试查询所有
	  public void testFindAll(){
		List<Role> roles = roleDao.findAll();
		for (Role role : roles){
			System.out.println("---每个角色的信息----");
			System.out.println(role);
			System.out.println(role.getUsers());
		}
	}
}

3.2 实现User到Role的多对多

3.2.1 业务要求及实现SQL

需求：实现查询所有用户信息并关联查询出每个用户的角色列表。
分析：从User出发，我们也可以发现一个用户可以具有多个角色，这样用户到角色的关系也还是一对多关系。这样我们就可以认为User与Role的多对多关系，可以被拆解成两个一对多关系来实现。下面是实现的SQL语句：

SELECT u.*, r.id AS rid, r.role_name, r.role_desc
FROM user u
	INNER JOIN user_role ur ON u.id = ur.uid
	INNER JOIN role r ON r.id = ur.rid

3.2.2 修改用户实体类

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

public class User implements Serializable {
    private Integer id;
    private String username;
    private String address;
    private String sex;
    private Date birthday;

    // 一个user可对应多个account
    private List<Account> accounts;
    // 一个user只能有一个role
    private List<Role> roles;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

    public List<Account> getAccounts() {
        return accounts;
    }

    public void setAccounts(List<Account> accounts) {
        this.accounts = accounts;
    }

    public List<Role> getRoles() {
        return roles;
    }

    public void setRoles(List<Role> roles) {
        this.roles = roles;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + ''' +
                ", address='" + address + ''' +
                ", sex='" + sex + ''' +
                ", birthday=" + birthday +
                ", accounts=" + accounts +
                ", roles=" + roles +
                '}';
    }
}

3.2.3 修改映射文件

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ithema.dao.IUserDao">
    <!-- 建立对应关系 -->
    <resultMap type="user" id="userMap">
        <id column="id" property="id"/>
        <result column="username" property="username"/>
        <result column="sex" property="sex"/>
        <result column="birthday" property="birthday"/>
        <result column="address" property="address"/>

        <!-- collection是用于指定多方，为一个集合（List<Account>） -->
        <collection property="accounts" ofType="account">
            <id column="aid" property="id"/>
            <result column="uid" property="uid"/>
            <result column="money" property="money"/>
        </collection>
        <!-- 一个用户可能有多个角色（List<Role>） -->
        <collection property="roles" ofType="role">
            <id property="roleId" column="rid"></id>
            <result property="roleName" column="role_name"></result>
            <result property="roleDesc" column="role_desc"></result>
        </collection>
    </resultMap>
    <select id="findAll" resultMap="userMap">
    	SELECT u.*, r.id AS rid, r.role_name, r.role_desc FROM user u INNER JOIN user_role ur ON u.id = ur.uid INNER JOIN role r ON r.id = ur.rid
    </select>
</mapper>

最后

以上就是威武超短裙为你收集整理的七、MyBatis多表查询1 一对一查询（多对一）的全部内容，希望文章能够帮你解决七、MyBatis多表查询1 一对一查询（多对一）所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。

本图文内容来源于网友提供，作为学习参考使用，或来自网络收集整理，版权属于原作者所有。

本文分类：MyBatis
浏览次数：56 次浏览
发布日期：2024-07-15 19:30:01
本文链接：https://www.kaopuke.com/article/k-p-k_13_u_7_o_18_fy_14_j_14_w.html

七、MyBatis多表查询1 一对一查询（多对一）

概述

1 一对一查询（多对一）

1.1 方式一

1.1.1 定义账户信息的实体类

1.1.2 编写SQL语句

1.1.3 定义AccountUser类

1.1.4 定义账户的持久层Dao接口

1.1.5 定义AccountDao.xml文件中的查询配置信息

1.1.6 创建AccountTest测试类

1.1.7 小结

1.2 方式二

1.2.1 修改Account类

1.2.2 修改AccountDao接口中的方法

1.2.3 重新定义AccountDao.xml文件

1.2.4 在AccountTest类中加入测试方法

2 一对多查询

2.1 编写SQL语句

2.2 User类加入List<Account>

2.3 用户持久层Dao接口中加入查询方法

2.4 用户持久层Dao映射文件配置

2.5 测试方法

3 多对多查询

3.1 实现Role到User多对多

3.1.1 用户与角色的关系模型

3.1.2 业务要求及实现SQL

3.1.3 编写角色实体类

3.1.4 编写Role持久层接口

3.1.5 编写映射文件

3.1.6 编写测试类

3.2 实现User到Role的多对多

3.2.1 业务要求及实现SQL

3.2.2 修改用户实体类

3.2.3 修改映射文件

最后

评论列表共有 0 条评论

发表评论取消回复

七、MyBatis多表查询1 一对一查询（多对一）

概述

1 一对一查询（多对一）

1.1 方式一

1.1.1 定义账户信息的实体类

1.1.2 编写SQL语句

1.1.3 定义AccountUser类

1.1.4 定义账户的持久层Dao接口

1.1.5 定义AccountDao.xml文件中的查询配置信息

1.1.6 创建AccountTest测试类

1.1.7 小结

1.2 方式二

1.2.1 修改Account类

1.2.2 修改AccountDao接口中的方法

1.2.3 重新定义AccountDao.xml文件

1.2.4 在AccountTest类中加入测试方法

2 一对多查询

2.1 编写SQL语句

2.2 User类加入List<Account>

2.3 用户持久层Dao接口中加入查询方法

2.4 用户持久层Dao映射文件配置

2.5 测试方法

3 多对多查询

3.1 实现Role到User多对多

3.1.1 用户与角色的关系模型

3.1.2 业务要求及实现SQL

3.1.3 编写角色实体类

3.1.4 编写Role持久层接口

3.1.5 编写映射文件

3.1.6 编写测试类

3.2 实现User到Role的多对多

3.2.1 业务要求及实现SQL

3.2.2 修改用户实体类

3.2.3 修改映射文件

最后

相关文章

评论列表共有 0 条评论

发表评论 取消回复

发表评论取消回复