关闭

映射 关联关系

298人阅读 评论(0) 收藏 举报
分类:

一 关联关系的种类

        1. 单向  多对 1

        2. 单向 1 对多

        3. 双向  多对1

        4. 双向 1 对多

        5. 一对一

                     ①. 外键映射

                     ②. 主键映射

        6. 单向 多对多

        7. 双向 多对多

        8. 继承关系

解释:

什么是单向? 单向就是: 可以通过A 中 B 的id 查找的B 中的对象,

                                          但是,不能通过B查到A 中的对象

                                   说白一点就是,可以通过我找到你,但是不能通过你来找我

什么是双向?双向就是: 可以通过A 中 B 的id 查找的B 中的对象,

                                          但是,也能通过B查到A 中的对象

                                   说白一点就是,可以通过我找到你,也可以通过你来找我

什么是多?多:就是集合 set

什么是1? 1  :就是1那一端的类的一个对象  

                    因此:把 “对”字后面的放入前面里面: 后面是 多,就放set 集合

                                                                                 后面是 1 ,就放一个类的对象

单向 1 对多:就是 在这一端放入一个那一端的set集合;

单向 多对 1:就是在 多 这一端,放入一个 1  这一端类的对象

双向 多对 1就是在 多 这一端,放入一个 1  这一端类的对象;

                     再这一端放入一个 多 那一端的set集合 

双向 1 对多这一端放入一个 多 那一端的set集合 

                      在 多 这一端,放入一个 1  这一端类的对象

1 对 1 :就是分别在对方中放一个自己类的对象(注意:是一个对象,不是一个集合)

多对多就是分别在对方中放一个自己类的集合(注意:是一个集合,不是一个对象)




关联关系常用到的属性:


        

        

        

        

        

~~~~~~~~~分割线~~~~~~下面是示例~~~~~~~~~

 orders:订单表 customer:客户表 

1. 单向  多对 1 :一个客户可以有多个定点,因此,客户是1 订单是多, 需要该订单 中添加Customer 类的属性



持久化类

Customer.java

package com.baidu.n21;

//演示单项   多对一
public class Customer {
	private Integer customerId;
	private String customerName;
		
	public Integer getCustomerId() {
		return customerId;
	}
	public void setCustomerId(Integer customerId) {
		this.customerId = customerId;
	}
	public String getCustomerName() {
		return customerName;
	}
	public void setCustomerName(String customerName) {
		this.customerName = customerName;
	}
}
Order.java

package com.baidu.n21;

public class Order {
	private Integer orderId;
	private String orderName;
	
	private Customer customer;

	public Integer getOrderId() {
		return orderId;
	}
	public void setOrderId(Integer orderId) {
		this.orderId = orderId;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}

	public Customer getCustomer() {
		return customer;
	}
	public void setCustomer(Customer customer) {
		this.customer = customer;
	}
}

对象关系映射

Customer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.baidu.n21.Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" />
        </property>
        
    </class>
    
</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!-- Generated 2016-5-20 13:07:11 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping package="com.baidu.n21">

    <class name="Order" table="ORDERS">
    
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <!-- 
        	映射 多对一 的关联关系,使用many-to-one 来映射多对1 的关联关系,
        	name:多这一端关联的一那一端的属性的名称
        	class: 一那一端的属性对应的类名
        	column:一那一端在多的一端对应的数据表中的外键的名字,这个名字可以和一那一端的不一样
        			如:	一那一端的之间可以为: 			CUSTOMER_ID,
        				而器在多这一端表中的名字可以为:	CUS_ID
         -->
        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID" ></many-to-one>
        
    </class>
    
</hibernate-mapping>

测试 代码详见: 点我去看详解代码


2. 单向 1 对多

班级 class,学生  student

班级和学生是   1 对 多 ,一个班级里可以有多名学生


持久化类

Classbj.java

package com.baidu.l2n;

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

//单向    1 对  多  。 1 这一端
public class Classbj {
	
	/**
	 * orders
	 * 
	 * 1. 声明集合类型时,需要使用接口类型,
	 * 		因为hibernate 在获取集合类型时,返回的是Hibernate 内置的集合类型,
	 * 		而不是JaveSE 的一个标准的集合实现
	 * 2. 需要把集合进行初始化,可防止 发生空指针异常
	 */
	
	private Integer classId;
	private String  className;
	
	private Set<Student> stus = new HashSet<Student>();

	public Integer getClassId() {
		return classId;
	}
	public void setClassId(Integer classId) {
		this.classId = classId;
	}
	public String getClassName() {
		return className;
	}
	public void setClassName(String className) {
		this.className = className;
	}
	public Set<Student> getStus() {
		return stus;
	}
	public void setStus(Set<Student> stus) {
		this.stus = stus;
	}
}

Student.java

package com.baidu.l2n;

// 单向    1 对  多  。 多这一端
public class Student {
	
	private Integer stuId;
	private String stuName;
	
	public Integer getStuId() {
		return stuId;
	}
	public void setStuId(Integer stuId) {
		this.stuId = stuId;
	}
	public String getStuName() {
		return stuName;
	}
	public void setStuName(String stuName) {
		this.stuName = stuName;
	}
	@Override
	public String toString() {
		return "Student [stuId=" + stuId + ", stuName=" + stuName + "]";
	}
	
}
对象关系映射

Clazz.hbm.xml

<hibernate-mapping package="com.baidu.l2n">

    <class name="Clazz" table="CLAZZS">
    
        <id name="clazzId" type="java.lang.Integer">
            <column name="CLAZZ_ID" />
            <generator class="native" />
        </id>
        
        <property name="className" type="java.lang.String">
            <column name="CLAZZ_NAME" />
        </property>
        
        <!-- 映射1 对多的那个集合属性  -->
        <!-- 
        	set:映射set类型的属性,
        	table:set 中的元素对应的记录放到哪一个数据表中。该值需要和多对1 的多的那个表中的名字一致
        	inverse:指定 inverse=true,使1 的一端放弃维护关联关系
        	column: 
        	lazy:
        	
        	
        	cascade:设置级联操作: 开发时,不建议设定该属性,建议使用手工的方式来处理
        		级联操作的取值有一下几种:
        			all: 所有情况下均进行关联操作,即save-update和delete。
					none: 所有情况下均不进行关联操作。这是默认值。 
					save-update: 在执行save/update/saveOrUpdate时进行关联操作。 
					delete: 在执行delete 时进行关联操作。
					all-delete-orphan: 当一个节点在对象图中成为孤儿节点时,删除该节点
         -->
        
        <set name="stus" table="STUDENTS" inverse="false" >
         <!-- 指定多的表中的外键列的名字  -->
            <key>
                <column name="CLAZZ_IDQ" />
            </key>
          <!-- 指定映射类型  -->
            <one-to-many class="Student" />
        </set>
        
    </class>
    
</hibernate-mapping>


Student.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

    <class name="com.baidu.l2n.Student" table="STUDENTS">
    
        <id name="stuId" type="java.lang.Integer">
            <column name="STU_ID" />
            <generator class="native" />
        </id>
        
        <property name="stuName" type="java.lang.String">
            <column name="STU_NAME" />
        </property>
        
    </class>
    
</hibernate-mapping>
测试 代码详见: 点我去看详解代码



.


1. 对象关系映射

Customer.hbm.xml

<hibernate-mapping package="com.baidu.doubleOne2Many">

    <class name="Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
        
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_Name" />
        </property>
        
        <!-- 映射1 对多的那个集合属性  -->
        <!-- 
        	set:映射set类型的属性,
        	table:set 中的元素对应的记录放到哪一个数据表中。该值需要和多对1 的多的那个表中的名字一致
        	inverse:指定 inverse=true,使1 的一端放弃维护关联关系
        	
        	cascade:设置级联操作: 开发时,不建议设定该属性,建议使用手工的方式来处理
        		级联操作的取值有一下几种:
        			all: 所有情况下均进行关联操作,即save-update和delete。
					none: 所有情况下均不进行关联操作。这是默认值。 
					save-update: 在执行save/update/saveOrUpdate时进行关联操作。 
					delete: 在执行delete 时进行关联操作。
					all-delete-orphan: 当一个节点在对象图中成为孤儿节点时,删除该节点
         -->
        <set name="orders" table="ORDERS"  >
        	<!-- 指定多的表中的外键列的名字  -->
        	<key column="CUST_ID" ></key>
        	 <!-- 指定映射类型  -->
        	<one-to-many class="Order" />
        </set>
        
    </class>
    
</hibernate-mapping>


Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.doubleOne2Many">

    <class name="Order" table="ORDERS">
    
        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" />
        </property>
        
        <many-to-one name="customer" class="Customer" >
            <column name="CUST_ID" />
        </many-to-one>
        
    </class>
    
</hibernate-mapping>



2.  两个持久化类

/**
*orders

* 1. 声明集合类型时,需要使用接口类型Set,
*因为hibernate 在获取集合类型时,返回的是Hibernate 内置的集合类型,
*而不是JaveSE 的一个标准的集合实现
* 2.需要把集合进行初始化,可放在 发送空指针异常
*/




测试 代码详见:点我去看详解代码





一对一关联:主键关联外键关联

主键关联:不必加额外的字段,只是主表和辅表的主键相关联,即这两个主键的值是一样的。

外键关联:辅表有一个额外的字段和主表相关联,或者两个表都有额外的字段与对应表的相关联。

    (1) name: 属性的名字。

    (2) class (可选 - 默认是通过反射得到的属性类型):被关联的类的名字。

    (3) cascade(级联) (可选):表明操作是否从父对象级联到被关联的对象。

    (4) constrained(约束) (可选):表明该类对应的表对应的数据库表,和被关联的对象所对应的数据库表之间,通过一个外键                                   引用对主键进行约束。 这个选项影响save()delete()在级联执行时的先后顺序以及 决定                                   该关联能否被委托(也在schema export tool中被使用).

    (5) fetch (可选 - 默认设置为选择): 在外连接抓取或者序列选择抓取选择其一.

    (6) property-ref (可选):指定关联类的属性名,这个属性将会和本类的主键相对应。如果没有指定,会使用对方关联类的主                             键。

    (7) access (可选 - 默认是 property): Hibernate用来访问属性的策略。

    (8) formula (可选):绝大多数一对一的关联都指向其实体的主键。在一些少见的情况中, 你可能会指向其他的一个或多个字                        段,或者是一个表达式,这些情况下,你可以用一个SQL公式来表示。 (可以                                                在org.hibernate.test.onetooneformula找到例子)

    (9) lazy (可选 - 默认为 proxy): 默认情况下,单点关联是经过代理的。lazy="no-proxy"指定此属性应该在实例变量第一次                                     被访问时应该延迟抓取(fetche lazily)(需要运行时字节码的增                                                         强)。 lazy="false"指定此关联总是被预先抓取。注意,如果constrained="false", 不                                     可能使用代理,Hibernate会采取预先抓取!

   (10) entity-name (可选): 被关联的类的实体名。


1. 外键关联

: Person 和Card,一个用户对应一个卡

        这种关联Card 中是用 many-to-one, 然后用unique="true" 做限制,限制成一对一的关系。所以,一对一的外键关联其实就是多对一关联的一种特例。






1. 持久化类

Card.java

package com.baidu.one2one.foreign;

public class Card {
	
	private  Integer cardId;
	private String  cardName;
	
	private Person person;
	
	public Integer getCardId() {
		return cardId;
	}
	public void setCardId(Integer cardId) {
		this.cardId = cardId;
	}

	public String getCardName() {
		return cardName;
	}
	public void setCardName(String cardName) {
		this.cardName = cardName;
	}

	public Person getPerson() {
		return person;
	}
	public void setPerson(Person person) {
		this.person = person;
	}
}
Person.java

package com.baidu.one2one.foreign;

public class Person {
	private  Integer personId;
	private String  personName;
	private Integer age;
	
	private Card card;

	public Integer getPersonId() {
		return personId;
	}
	public void setPersonId(Integer personId) {
		this.personId = personId;
	}

	public String getPersonName() {
		return personName;
	}
	public void setPersonName(String personName) {
		this.personName = personName;
	}

	public Integer getAge() {
		return age;
	}
	public void setAge(Integer age) {
		this.age = age;
	}

	public Card getCard() {
		return card;
	}
	public void setCard(Card card) {
		this.card = card;
	}
}

2. hbm.xml

Card.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.foreign">

    <class name="Card" table="CARDS">
    
        <id name="cardId" type="java.lang.Integer">
            <column name="CARD_ID" />
            <generator class="native" />
        </id>
        
        <property name="cardName" type="java.lang.String">
            <column name="CARD_NAME" />
        </property>
   		
   		 <!-- 使用many-to-one 的方式来映射  one-to-one关联关系的外键 -->
   		<many-to-one name="person" class="Person" column="PERS_ID" unique="true"></many-to-one>
        
    </class>
    
</hibernate-mapping>
Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.foreign">

    <class name="Person" table="PERSONS">
    
        <id name="personId" type="java.lang.Integer">
            <column name="PERSON_ID" />
            <generator class="native" />
        </id>
        
        <property name="personName" type="java.lang.String">
            <column name="PERSON_NAME" />
        </property>
        
        <property name="age" type="java.lang.Integer">
            <column name="AGE" />
        </property>
        
        <!-- 映射 one-to-one关联关系:因为在对应的数据表中已经有外键了,
        						  当前持久化类使用one-to-one 进行映射
        						  
        	这种关联Card 中是用 many-to-one, 然后用unique="true" 做限制,限制成一对一的关系。
        	所以,一对一的外键关联其实就是多对一关联的一种特例。
        	 -->
        <one-to-one name="card" class="Card" ></one-to-one>
       
    </class>
    
</hibernate-mapping>

测试 代码详见:点我去看详解代码

2. 主键关联


1. 持久化类

Card.java

public class Card {
	
	private  Integer cardId;
	private String  cardName;
	
	private Person person;
	
	...这里是getter 和setter
}
Person.java
package com.baidu.one2one.primary;

public class Person {
	private  Integer personId;
	private String  personName;
	private Integer age;
	
	private Card card;

	....这里是getter 和setter
	
}

2. hbm.xml

Card.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.primary">

    <class name="Card" table="CARDS">
    
        <id name="cardId" type="java.lang.Integer">
            <column name="CARD_ID" />
               <!-- 使用外键的方式来生成当前的主键 -->
            <generator class="foreign">
            <!-- property 属性指定使用当前持久化类的哪一属性的主键作为外键 -->
            	<param name="property">person</param>
            </generator>
        </id>
        
        <property name="cardName" type="java.lang.String">
            <column name="CARD_NAME" />
        </property>
        
       <!-- 
		  使用foreign 主键生成器策略的一端  增加one-to-one 元素映射关联关系属性,
		  其中one-to-one 节点 还应增加 constrained="true" 属性; 以使当前的主键上添加外键约束。
		  另一端增加 one-to-one 元素映射关联属性
       -->
        <one-to-one name="person" class="Person" constrained="true"></one-to-one>
   
    </class>
    
</hibernate-mapping>

Person.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.baidu.one2one.primary">

    <class name="Person" table="PERSONS">
        
        <id name="personId" type="java.lang.Integer">
            <column name="PERSON_ID" />
            <generator class="native" />
        </id>
        
        <property name="personName" type="java.lang.String">
            <column name="PERSON_NAME" />
        </property>
        
        <property name="age" type="java.lang.Integer">
            <column name="AGE" />
        </property>
        
        <one-to-one name="card" class="Card"></one-to-one>
    
    </class>
    
</hibernate-mapping>

测试 代码详见:点我去看详解代码




        多对多关联是常见的一种关联关系,如User与Role,一个用户可以对应多个角色,一个角色也可以对应多个用户。


1. 单向 多 对 多



  

持久化类:

Role.java

public class Role {

	private Integer rId;
	private String rName;
	下面是getter 和setter..
}
User.java
import java.util.Set;

public class User {
	private Integer uId;
	private String uName;
	
	private Set<Role> roles;
	
	下面是getter 和setter..
}

关系映射:

Role.hbm.xml

<hibernate-mapping>

    <class name="com.baidu.many2many.Role" table="ROLES">
    
        <id name="rId" type="java.lang.Integer">
            <column name="R_ID" />
            <generator class="native" />
        </id>
        
        <property name="rName" type="java.lang.String">
            <column name="R_NAME" />
        </property>
        
    </class>
    
</hibernate-mapping>
User.hbm.xml
<hibernate-mapping package="com.baidu.many2many">

    <class name="User" table="USERS">
    
        <id name="uId" type="java.lang.Integer">
            <column name="U_ID" />
            <generator class="native" />
        </id>
        
        <property name="uName" type="java.lang.String">
            <column name="U_NAME" />
        </property>
         <!-- table:指定中间表 -->
        <set name="roles" table="T_USERS_ROLES">
            <key>
                <column name="U_ID" />
            </key>
              <!-- 使用many-to-many 指定多对多的关联关系 column:指定Set 集合中的持久化类在中间表的外键列的名称 -->
            <many-to-many class="Role">
            	<column name="R_ID"></column>
            </many-to-many>
        </set>
        
    </class>
    
</hibernate-mapping>

测试 代码详见:点我去看详解代码



2. 双向 多 对 多




修改持久化类

Role.java

package com.baidu.many2many;

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

public class Role {

	private Integer rId;
	private String rName;
	//修改这里
	private Set<User> users = new HashSet<User>() ;
	
	下面是getter 和setter..
}


修改 对象关系映射

Role.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping  package="com.baidu.doublemany2many">

    <class name="Role" table="ROLE">
    
        <id name="rId" type="java.lang.Integer" >
            <column name="R_ID" />
            <generator class="native" />
        </id>
        
        <property name="rName" type="java.lang.String">
            <column name="R_NAME" />
        </property>
        
        <set name="users" table="T_USER_ROLE" inverse="true">
            <key>
                <column name="R_ID" />
            </key>
          	<many-to-many class="User">
          		<column name="U_ID"></column>
          	</many-to-many>
        </set>
        
    </class>
    
</hibernate-mapping>

测试 代码详见:点我去看详解代码


继承关系




持久化类:

Person.java

public class Person {
	
	private Integer id;
	private  String  name;
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}
Student.java
public class Student extends Person {

	private  String school;

	public String getSchool() {
		return school;
	}
	public void setSchool(String school) {
		this.school = school;
	}
	
}




<hibernate-mapping package="com.baidu.subclass">

	<!-- discriminator-value 的值:PERSON 可以随便写 -->
    <class name="Person" table="PERSONS" discriminator-value="PERSON">
    
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>

        <!-- 指定辨别者列  -->
		 <discriminator column="TYPE" type="string"></discriminator>       
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        <!-- 映射子类Strudent ,使用subclass 进行映射 -->
        	<subclass name="Student" discriminator-value="STUDENT">
        		<property name="school" type="string" column="SCHOOL"></property>
        	</subclass>
        
    </class>
    
</hibernate-mapping>


测试 代码详见:点我去看详解代码




<hibernate-mapping package="com.baidu.jionSubclass">

	<!-- discriminator-value 的值:PERSON 可以随便写 -->
    <class name="Person" table="PERSONS">
    
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
    
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        <!-- 映射子类Strudent ,使用joined-subclass 进行映射 -->
       
        <joined-subclass name="Student" table="STUDENTS">
        		<key column="STUDENT_ID"></key>
        		<property name="school" type="string" column="SCHOOL"></property>
        </joined-subclass>
        
    </class>
    
</hibernate-mapping>
测试 代码详见:点我去看详解代码



<hibernate-mapping package="com.baidu.UnionSubclass">

	<!-- discriminator-value 的值:PERSON 可以随便写 -->
    <class name="Person" table="PERSONS">
    
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="hilo" />
        </id>
    
        
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        
        <property name="age" type="int">
            <column name="AGE" />
        </property>
        
        <!-- 映射子类Strudent ,使用union-subclass 进行映射 -->
       
        <union-subclass name="Student" table="STUDENTS">
        		<property name="school" type="string" column="SCHOOL"></property>
        </union-subclass>
        
    </class>
    
</hibernate-mapping>

测试 代码详见:点我去看详解代码
















0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:115064次
    • 积分:2532
    • 等级:
    • 排名:第15973名
    • 原创:135篇
    • 转载:47篇
    • 译文:0篇
    • 评论:17条
    最新评论