文章目录
一、集合映射
参考：https://mp.weixin.qq.com/s/w9YWxMtK_bajTauSf4nKvQ
需求分析：当用户购买商品，用户可能有多个地址。
集合元素类型：String类型。
1.1 数据库表
用户表：保存着用户的信息。
地址表：保存着地址的信息。地址表使用外键来引用用户表
1.2 实体
由于地址只是使用String类型来保存着，那么我们直接使用一个User对象就可以了。
User.java
public class User {
private String id;
private String username;
private String password;
private Set<String> address; // 集合。
//各种setter和getter
}
1.3 映射文件——set集合
User.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.my.entity">
<class name="User" table="user">
<!--主键映射-->
<id name="id" column="id" >
<generator class="native"/>
</id>
<!--普通字段映射-->
<property name="username" column="username"/>
<property name="password" column="password"/>
<!--
Set：
name： 映射集合的名称
table：集合的属性要映射到哪张表(address)
key：
column：指定要映射的表（address）中的外键列
element：要映射的表的其他字段类型一定要指定！
-->
<set name="address" table="address">
<key column="user_id"/>
<element column="addr" type="string"/>
</set>
</class>
</hibernate-mapping>
1.4 测试
App.java
public class App {
private Configuration configuration; //获取加载配置管理类
private SessionFactory factory; //创建Session工厂对象
private Session session; //得到Session对象
private Transaction transaction; //得到Session对象
// 获取session。
public static Session getSession() {
configuration = new Configuration();
configuration.configure(); //加载映射文件！
//configuration.configure().addClass(Dept.class).addClass(Employee.class);
factory = configuration.buildSessionFactory();
return factory.openSession();
}
public static void testCollectionMapping() {
session = getSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
transaction = session.getTransaction();
transaction.begin();//开启事务
//创建对象
User user = new User();
user.setUsername("123");
user.setPassword("1234");
user.getAddress().add("广州");
session.save(user);
transaction.commit();//提交事务
session.close();//关闭Session
}
}
1.5 List集合
List集合和Set集合有什么区别…List集合是有序的，因此要多配置一个列来维护数据的有序性！
<list name="address" table="address">
<key column="user_id"/>
<!--index是关键字，不能使用！！！！-->
<list-index column="indexNum"/>
<element column="addr" type="string"/>
</list>
1.6 Map集合
Map集合和Collection集合的区别就是键值对模型，那么在配置的时候多一个key即可！
<map name="address" table="address">
<key column="user_id" />
<map-key type="string" column="short"/>
<element type="string" column="addr"/>
</map>
二、一对多和多对一映射
需求：部门与员工之间的关系。
——一个部门有多个员工; 【一对多】
——多个员工，属于一个部门 【多对一】
集合元素类型：对象。
2.1 数据库表
员工表应该使用一个外键来记住部门表。这样才可以维护员工和部门之间的关系。
2.2 实体
部门实体要使用一个集合来记住所有的员工，员工要使用一个对象引用着部门。
Dept.java
public class Dept {
private int id ;
private Set<Employee> set = new HashSet<Employee>();
private String deptName;
}
Employee.java
public class Employee {
private int id;
private String empName;
private double salary;
private Dept dept;
}
2.3 映射文件
Dept.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.my.entity">
<class name="Dept" table="dept">
<id column="id" name="id">
<generator class="native"/>
</id>
<!--普通字段映射-->
<property name="deptName" column="deptname"/>
<!--维护关系的是Set集合，对应employee表-->
<set cascade="save-update" name="set" table="employee">
<!--employee的外键列是dept_no-->
<key column="dept_no"/>
<!--一个部门对应多个员工，集合的类型是Employee-->
<one-to-many class="Employee"/>
</set>
</class>
</hibernate-mapping>
Employee.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">
<!--在domain包下-->
<hibernate-mapping package="com.my.entity">
<class name="Employee" table="employee">
<id column="id" name="id">
<generator class="native"/>
</id>
<!--普通字段数据-->
<property name="empName" column="empName"/>
<property name="salary" column="salary"/>
<!--Hibernate这个标签可看成在当前表中设置一个外键dept_no-->
<many-to-one name="dept" class="Dept" column="dept_no"/>
</class>
</hibernate-mapping>
2.4 测试
App.java
// 在“一”的一方测试
public static void testOneMapping() {
session = getSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
transaction = session.getTransaction();
transaction.begin(); //开启事务
//创建对象
Dept dept = new Dept();
dept.setDeptName("开发部");
Employee zs = new Employee();
zs.setEmpName("张珊");
zs.setSalary(1111);
Employee ls = new Employee();
ls.setEmpName("李四");
ls.setSalary(2222);
//添加关系
dept.getSet().add(zs);
dept.getSet().add(ls);
session.save(dept);
session.save(zs);
session.save(ls);
transaction.commit();//提交事务
session.close();//关闭Session
}
// 在“多”的一方测试
public static void testManyMapping() {
session = getSession();
transaction = session.getTransaction();
transaction.begin(); //开启事务
//创建对象
Dept dept = new Dept();
dept.setDeptName("开发部");
Employee zs = new Employee();
zs.setEmpName("张珊");
zs.setSalary(1111);
Employee ls = new Employee();
ls.setEmpName("李四");
ls.setSalary(2222);
//维护关系
zs.setDept(dept);
ls.setDept(dept);
//添加关系
session.save(dept);
session.save(zs);
session.save(ls);
transaction.commit();//提交事务
session.close();//关闭Session
}
2.5 总结
保存数据，最好的通过多的一方来维护关系，这样可以减少update语句的生成，从而提高hibernate的执行效率！
| 关联 | 含义 |
|---|---|
| 双向关联 | 配置一对多与多对一 |
| 单项一对多关联 | 只配置一对多 |
| 单项多对一 | 只配置多对一 |
配置了哪一方，哪一方才有维护关联关系的权限！
三、多对多映射
需求：一个项目由多个员工开发，一个员工开发多个项目
集合元素类型：对象。
3.1 数据库表
一般地，如果是多对多的映射，我们都会使用一张中间表来保存它们的关联关系。
3.2 实体
一般是核心数据表对应一个JavaBean实体【中间表并不是核心数据表】，那么我们将会设计两个JavaBean对象。
Project.java
public class Project {
private int projectId;
private String projectName;
//使用Set集合与developer实体维护关系
private Set<Developer> developers = new HashSet<>();
}
Developer.java
public class Developer {
private int developerId;
private String developerName;
//使用Set集合来维护与Project关系
private Set<Project> projects = new HashSet<>();
}
3.3 映射文件
Project.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.my.many2many">
<class name="Project" table="Project">
<id name="projectId" column="projectId">
<generator class="native"/>
</id>
<!--映射普通字段-->
<property name="projectName" column="projectName"/>
<!--映射多对多的关系-->
<!--Set的属性名称为developers，对应developer_project表-->
<set name="developers" table="developer_project">
<!--对应developer_project表的外键列-->
<key column="project_id"/>
<!--集合的类型和developer_project表的另一个外键列-->
<many-to-many column="developer_id" class="Developer"/>
</set>
</class>
</hibernate-mapping>
Developer.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.my.many2many">
<class name="Developer" table="Developer">
<!--映射主键-->
<id name="developerId" column="developerId">
<generator class="native"/>
</id>
<!--映射普通字段-->
<property name="developerName" column="developerName"/>
<!--映射多对多的关系-->
<!--Set的属性名称为developers，对应developer_project表-->
<set name="projects" table="developer_project">
<!--对应developer_project表的外键列-->
<key column="developer_id"/>
<!--集合的类型和developer_project表的另一个外键列-->
<many-to-many column="project_id" class="Project"/>
</set>
</class>
</hibernate-mapping>
3.4 测试
App.java
public static void testMany2ManyMapping() {
session = getSession();
//使用Hibernate操作数据库，都要开启事务,得到事务对象
transaction = session.getTransaction();
//开启事务
transaction.begin();
//创建对象
Developer cj = new Developer();
Developer wc = new Developer();
Developer lz = new Developer();
Project ds = new Project();
Project oa = new Project();
//设置对象的数据
cj.setDeveloperName("曹吉");
wc.setDeveloperName("王春");
lz.setDeveloperName("老张");
oa.setProjectName("OA系统");
ds.setProjectName("电商系统");
//使用Project来关联数据【在多对多中，一样的】
oa.getDevelopers().add(wc);
oa.getDevelopers().add(lz);
ds.getDevelopers().add(cj);
ds.getDevelopers().add(wc);
//在Project映射文件中设置级联保存了
session.save(oa);
session.save(ds);
//提交事务
transaction.commit();
//关闭Session
session.close();
}
四、一对一的映射
需求：用户与身份证信息…一个用户对应一个身份证
集合元素类型：对象。
4.1 数据库表
第一种：在身份证的数据表中设置一个外键来维护用户的关系。这个外键也应该是唯一的【一个用户对应一张身份证】。
第二种：在身份证的数据表中使用主键+外键的方式来维护用户的关系。
4.2 实体
IdCard.java
public class IdCard {
private int idCardId;
private String idCardName;
//维护与用户之间的关系
private User user ;
}
User.java
public class User {
private int userId;
private String userName;
//维护与身份证一对一的关系
private IdCard idCard ;
}
4.3 映射文件
4.3.1 外键方式
即在idCard表中，增加一个字段（user_id），此字段与user表主键字段关联。
该字段的作用：维护两表的关系。
User.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.my.one2one">
<class name="User" table="User">
<!--映射主键-->
<id name="userId" column="userId">
<generator class="native"/>
</id>
<!--映射普通字段-->
<property name="userName" column="userName"/>
<!--
User是没有外键字段的表
一对一的关系的属性名称name是idCard
类型是IdCard
-->
<one-to-one name="idCard" class="IdCard"/>
</class>
</hibernate-mapping>
IdCard.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.my.one2one">
<class name="IdCard" table="IdCard">
<id name="idCardId" column="idCardId">
<generator class="native"/>
</id>
<property name="idCardName" column="idCardName"/>
<!--idCart是有外键的表，要把字段映射成外键，用的是manyToOne-->
<!--
外键的属性name是user
对应表的字段是userId
属性的类型是User
该字段需要唯一性 unique
-->
<many-to-one name="user" column="user_id" class="User" unique="true" cascade="save-update"/>
</hibernate-mapping>
4.3.2 主键+外键方式
即在idCard表中，增加一个字段（user_id）作为主键字段且也是外键字段，此字段与user表主键字段关联。
需要在IdCard.java类中添加以下属性。
private int userId;
User.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.my.one2one">
<class name="User" table="User">
<id name="userId" column="userId">
<generator class="native"/>
</id>
<property name="userName" column="userName"/>
<one-to-one name="idCard" class="IdCard"/>
</class>
</hibernate-mapping>
IdCard.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.my.one2one">
<class name="userId" table="IdCard">
<!--映射主键-->
<id name="idCardId" column="userId">
<!--
做主键的同时也做外键
外键的类型名称为user
-->
<generator class="foreign">
<param name="property">user</param>
</generator>
</id>
<property name="idCardName" column="idCardName"/>
<property name="idCardId" column="idCartId"/>
<!--
有外键的一方：
基于主键映射，使用oneToOne
constrained="true" 指定在主键上添加外键约束
-->
<one-to-one name="user" class="User" constrained="true"/>
</hibernate-mapping>
4.4 测试
4.4.1 外键方式
使用IdCard来维护关联关系，直接保存其对象即可。
App.java
public static void testOne2OneMapping1() {
session = factory.getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
User user = new User();
IdCard idCard = new IdCard();
//设置对象的数据
user.setUserName("你好");
idCard.setIdCardName("身份证001");
//一对一关联数据
idCard.setUser(user);
//保存对象的数据,idCard配置文件使用级联保存
session.save(idCard);
transaction.commit();
session.close();
}
4.4.2 主键+外键方式
使用IdCard来维护关联关系，直接保存其对象即可。
App.java
public static void testOne2OneMapping2() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
User user = new User();
IdCard idCard = new IdCard();
//设置对象的数据
user.setUserName("你好");
idCard.setIdCardName("身份证001");
idCard.setIdCardId(4235);
//一对一关联数据
idCard.setUser(user);
//保存对象的数据,idCard配置文件使用级联保存
session.save(idCard);
transaction.commit();
session.close();
}
五、组件映射
组合关系：两个类不是继承关系，但两个类的亲密程度很高，在一个类里边需要用到另外一个类，那么就在类中定义一个变量来维护另一个类的关系。
组件映射：实际上就是将组合关系的数据映射成一张表，组件类和被包含的组件类映射成一张表。
Java类的主要关系：
——组合关系，组合关系对应的就是组件映射
——继承关系，继承关系对应的就是继承映射
需求：汽车和轮子。汽车需要用到轮子，但是轮子的爸爸不可能是汽车。
集合元素类型：对象。
5.1 数据库表
5.2 实体
Wheel.java
public class Wheel {
private int count;
private int size;
}
Car.java
public class Car {
private int id;
private String name;
private Wheel wheel; // 使用变量维护Wheel
}
5.3 映射文件
IdCard.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.my.component" >
<class name="Car" table="Car" >
<!--映射主键-->
<id name="id" column="id">
<generator class="native"/>
</id>
<!--映射普通字段-->
<property name="name" column="name"/>
<!--映射组件字段-->
<component name="wheel">
<property name="count"/>
<property name="size"/>
</component>
</class>
</hibernate-mapping>
5.4 测试
App.java
public static void testCompoentMapping() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
Wheel wheel = new Wheel();
Car car = new Car();
//设置对象的数据
wheel.setCount(43);
wheel.setSize(22);
car.setName("宝马");
//维护关系
car.setWheel(wheel);
//保存对象的数据,idCard配置文件使用级联保存
session.save(car);
transaction.commit();
session.close();
}
六、传统方式继承映射
传统方式继承的特点就是：有多少个子类就写多少个配置文件。
需求：动物、猫、猴子。猫继承着动物。
6.1 数据库表
id和name从Animal中继承，catchMouse是子类的具体行为。
6.2 实体
Animal.java
public abstract class Animal {
private int id;
private String name;
}
Cat.java
public class Cat extends Animal{
private String catchMouse;// 抓老鼠
}
6.3 映射文件
简单继承的映射文件很好写，在属性上，直接写父类的属性就可以了。
缺点：如果子类有很多，就需要写很多的配置文件。
Cat.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.my.extends" >
<class name="Cat" table="cat" >
<!--映射主键-->
<id name="id" column="id">
<generator class="native"/>
</id>
<!--
映射普通字段
父类的属性直接引用就行了，比如name属性，直接写就行了！
-->
<property name="name" column="name" />
<property name="catchMouse" column="catchMouse" />
</class>
</hibernate-mapping>
6.4 测试
App.java
public static void testExtentsMapping() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
Cat cat = new Cat();
//设置对象的数据
cat.setName("大花猫");
cat.setCatchMouse("捉大老鼠");
session.save(cat);
transaction.commit();
session.close();
}
每个子类都需要写成一个配置文件，映射成一张表。
七、把所有子类映射成一张表
将所有的子类都映射成一张表中。
7.1 数据库表
7.2 实体
实体和上面雷同，只多了一个猴子的实体表。
Monkey.java
public class Monkey extends Animal {
private String eatBanana;// 吃香蕉
}
7.3 映射文件
使用了subClass这个节点和鉴别器
<?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.my.extends">
<class name="Animal" table="t_animal">
<id name="id">
<generator class="native"/>
</id>
<!-- 指定鉴别器字段(区分不同的子类) -->
<discriminator column="type_"/>
<property name="name"/>
<!--
子类：猫
每个子类都用subclass节点映射
注意：一定要指定鉴别器字段，否则报错！
鉴别器字段：作用是在数据库中区别每一个子类的信息， 就是一个列
discriminator-value="cat_"
指定鉴别器字段,即type_字段的值
如果不指定，默认为当前子类的全名
-->
<subclass name="Cat" discriminator-value="cat_">
<property name="catchMouse"/>
</subclass>
<!--子类：猴子-->
<subclass name="Monkey" discriminator-value="monkey_">
<property name="eatBanana"/>
</subclass>
</class>
</hibernate-mapping>
7.4 测试
App.java
public static void testExtentsMapping2() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
Cat cat = new Cat();
Monkey monkey = new Monkey();
//设置对象的数据
cat.setName("大花猫");
cat.setCatchMouse("捉大老鼠");
monkey.setEatBanana("吃香蕉");
monkey.setName("大猴子");
session.save(cat);
session.save(monkey);
transaction.commit();
session.close();
}
八、每个类映射一张表(3张表)
父类和子类都各对应一张表。那么就有三张表了。
这种结构看起来是完全面向对象，但是表之间的结构会很复杂，插入一条子类的信息，需要两条SQL。
8.1 数据库表
8.2 实体
同上。
8.3 映射文件
使用到了< joined-subclass >这个节点。
<?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.my.extends">
<class name="Animal" table="t_animal">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!--
Animal下的子类映射成一张表
指定子类的类型，对应的表
指定子类的外键字段【需要对应Animal】
指定子类的普通属性
-->
<joined-subclass name="Cat" table="cat_">
<!--key对应的是外键字段-->
<key column="animal_id"/>
<property name="catchMouse"/>
</joined-subclass>
<joined-subclass name="Monkey" table="monkey_">
<!--key对应的是外键字段-->
<key column="animal_id"/>
<property name="eatBanana"/>
</joined-subclass>
</class>
</hibernate-mapping>
8.4 测试
每保存一个子类对象需要两条SQL语句！
App.java
public static void testExtentsMapping3() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
Cat cat = new Cat();
Monkey monkey = new Monkey();
//设置对象的数据
cat.setName("大花猫");
cat.setCatchMouse("捉大老鼠");
monkey.setEatBanana("吃香蕉");
monkey.setName("大猴子");
session.save(cat);
session.save(monkey);
transaction.commit();
session.close();
}
九、每个子类映射一张表， 父类不对应表(2张表)
提出问题：
1、使用过了一张表保存所有子类的数据，这不符合数据库设计规范。
2、每个子类、父类都拥有一张表…表结构太过于繁琐…添加信息时，过多的SQL。
解决问题：每个子类映射成一张表，父类不对应表…这和我们传统方式继承是一样的。只不过在hbm.xml文件中使用了这个节点，由于有了这个节点，我们就不需要每个子类都写一个配置文件了。
9.1 数据库表
9.2 实体
同上。
9.3 映射文件
1、想要父类不映射成数据库表，只要在class中配置为abstract即可
2、使用了union-subclass节点，主键就不能采用自动增长策略了。我们改成UUID即可。当然啦，对应的实体id类型要改成String。
<?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.my.extends">
<!--想要父类不映射成表，设置成abstract-->
<class name="Animal" abstract="true" >
<id name="id">
<!--若使用union-subclass节点，则主键生成策略不能是自增长，改成uuid即可-->
<generator class="uuid"/>
</id>
<property name="name"/>
<!--
将子类的信息都映射成一张表
给出属性的名称
属性对应的数据库表
普通字段
-->
<union-subclass name="Cat" table="cat_">
<property name="catchMouse"/>
</union-subclass>
<union-subclass name="Monkey" table="monkey_">
<property name="eatBanana"/>
</union-subclass>
</class>
</hibernate-mapping>
9.4 测试
App.java
public static void testExtentsMapping4() {
session = getSession();
transaction = session.getTransaction();
transaction.begin();
//创建对象
Cat cat = new Cat();
Monkey monkey = new Monkey();
//设置对象的数据
cat.setName("大花猫");
cat.setCatchMouse("捉大老鼠");
monkey.setEatBanana("吃香蕉");
monkey.setName("大猴子");
session.save(cat);
session.save(monkey);
transaction.commit();
session.close();
}
9.5 组件映射和继承映射总结
传统继承映射每个子类都对应一个配置文件，这样十分麻烦。因此.hbm.xml就给出了几个节点供我们使用.
9.5.1 subclass标签
表数：子类父类共有一张表。
缺点：
1、不符合数据库设计规范。
2、需要使用鉴别器。
9.5.2 joined-subclass标签
表数：子类、父类都有自己的表。
缺点：
1、表的结构太过繁琐。
2、插入数据时要生成SQL至少就要两条。
9.5.3 union-subclass标签——推荐
表数：子类拥有自己的表、父类不对应表。
缺点：
1、父类不对应表要使用abstract来修饰。
2、主键的id不能使用自增长策略，修改成UUID就好了。对应的JavaBean的id设置成String就好。
213
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
