《基于SSH框架设计》
-----考试大作业
课程名称基于SHH框架设计
项目名称Hibernate配置JPA注解
专业班级软件1603
学号
姓名张陆豪
2017年11月28日
1.Hibernate介绍
1.1 什么是Hibernate
Hibernate 是一个开源框架,与Struts 这种MVC(Model-View-Controller)框架不同的是,Hibernate 是一种ORM(Object/Relational Mapping)框架。
ORM 意为对象关系映射,因此Hibernate 会在Java 对象和关系数据库之间建立某种映射,以达到存取Java 对象的目的,是实现持久化存储(将内存中的数据存储在关系型的数据库、磁盘文件、XML数据文件中等等)的一种解决方案。
Hibernate 不仅管理Java 类到数据库表的映射(包括从Java 数据类型到SQL 数据类型的映射),还提供数据查询和获取数据的方法,可以大幅度减少开发时人工使用SQL 和JDBC 处理数据的时间。这正是它的设计目标,即将软件开发人员从大量相同的数据持久层相关编程工作中解放出来。
1.2 Hibernate 体系结构
一个简要的Hibernate 整体体系结构大致如下图所示:
从上图可以看出,Hibernate 使用数据库(Database)和配置信息(hibernate.properties 等)来为应用程序提供持久化服务(以及持久的对象Persistent Objects)。
我们再来看看Hibernate 运行时的体系结构。由于Hibernate非常灵活,且支持多种应用方案,所以这里我们只描述一下两种极端的情况。
“轻型”的体系结构方案
要求应用程序提供自己的JDBC 连接并管理自己的事务。这种方案使用了Hibernate API 的最小子集:
“全面解决”的体系结构方案
将应用层从底层的JDBC/JTA API 中抽象出来,而让Hibernate 来处理这些细节:
1.3基本APIs:
SessionFactory(org.hibernate.SessionFactory)
对于单个数据库映射关系经过编译后的内存缓存,它是线程安全且不可变的。是Session 生成的工厂实例,也是ConnectionProvider 的一个客户端(会用到ConnectionProvider)。它在进程或集群的级别上,为那些在事务之前可重复使用的数据提供了选择性的二级缓存。Session(org.hibernate.Session)
提供应用程序和持久化存储介质之间的一个单线程的会话对象,此对象生存期很短。它隐藏了JDBC 连接,也是Transaction 的工厂实例。对于应用的持久化对象及其集合,它提供了一个一级缓存;当遍历导航对象图或者根据持久化标识查找对象时,会用到这个一级缓存。
持久化的对象及其集合
具有持久化状态和业务功能的单线程对象,同样生存期很短。这些对象可能是普通的JavaBeans/POJOs(Plain Ordinary Java Object),它们只能与一个Session 相关联。一旦Session 被关闭,它们就会脱离持久化状态,并且可以被应用程序的任何层使用(比如跟表示层打交道的data transfer objects)
瞬态(transient)、脱管状态(detached)的对象及其集合
持久化的类目前没有和Session 相关联的实例。他们可能是因为在被应用实例化后还没有被持久化,也可能是由于实例化它们的Session 对象已经被关闭,从而脱离了持久化状态。事务(Transaction)(org.hibernate.Transaction)
(可选的)它是应用程序用来指定原子操作单元范围的对象,是一个单线程的、短生存周期的对象。它通过抽象把应用从底层的JDBC、JTA 以及CORBA 事务中隔离开。在某些
情况下,一个Session 可能涵盖多个Transactions 对象。尽管使用该对象是可选的,但事务的划分(无论是使用底层的API 还是使用Transaction 对象)都是不可选的。ConnectionProvider(org.hibernate.connection.ConnectionProvider)
(可选的)JDBC 连接的工厂和连接池。它通过抽象把应用从底层的DataSource 或者DriverManager 隔离开。这并不开放给应用程序使用,但对开发者而言是可以扩展或实现的。TransactionFactory(org.hibernate.TransactionFactory)
(可选的)生成Transaction 对象实例的工厂。仅供开发者扩展/实现用,并不开放给应用程序使用。
扩展接口(Extension Interfaces)
Hibernate 提供了很多可选的扩展接口,你可以通过实现它们来定制你的持久层的行为。
1.4 Hibernate 的优点
Hibernate 使用Java 反射机制而不是字节码增强程序来实现透明性。Hibernate 的性能好,因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库,从一对一到多对多的各种复杂关系。
2.Hibernate配置
2.1 Hiberata.cfg.xml
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"https://www.wendangku.net/doc/7b7840697.html,/dtd/hibernate-configuration-3.0.dtd">
3.三个持久化类
3.1顾客地址Address
publicint getId() {
return id;}
publicvoid setId(int id) {
this.id = id;}
public String getName() {
return name;}
publicvoid setName(String name) {
https://www.wendangku.net/doc/7b7840697.html, = name;
}
public String getCode() {
return code;}
publicvoid setCode(String code) {
thi s.code = code;}
public String getUsername() {
return username;}
publicvoid setUsername(String username) {
https://www.wendangku.net/doc/7b7840697.html,ername = username;}}
3.2顾客Customer
publicint getId() {
return id;}
publicvoid setId(int id) {
this.id = id;
}
public String getCustomername() {
return customername;}
publicvoid setCustomername(String customername) { this.customername = customername;}
public String getUsername() {
return username;}
publicvoid setUsername(String username) { https://www.wendangku.net/doc/7b7840697.html,ername = username;
}
public String getPassword() {
return password; }
publicvoid setPassword(String password) {
this.password = password;
}
public String getSex() {
return sex; }
publicvoid setSex(String sex) {
this.sex = sex; }
publicint getAge() {
return age;}
publicvoid setAge(int age) {
this.age = age; }
public String getPhone() {
return phone;}
publicvoid setPhone(String phone) {
this.phone = phone;}}
3.3商品Product
@Entity
@Table(name = "product")
@Inheritance(strategy=InheritanceType.JOINED) publicclass Product {
privateint id;
private String name;
private String code;
privatedouble money;
private String picture;
private String content;
@Id
@GeneratedValue
publicint getId() {
return id;}
publicvoid setId(int id) {
this.id = id;}
public String getName() {
return name; }
publicvoid setName(String name) {
https://www.wendangku.net/doc/7b7840697.html, = name; }
public String getCode() {
return code; }
publicvoid setCode(String code) {
this.code = code; }
publicdouble getMoney() {
return money; }
publicvoid setMoney(double money) {
this.money = money; }
public String getPicture() {
return picture; }
publicvoid setPicture(String picture) {
this.picture = picture; }
public String getContent() {
return content; }
publicvoid setContent(String content) {
this.content = content; }}
4.一个主程序类
4.1顾客地址Address的增加、删除、修改、查询
static Session session;
static List
static List
publicstaticvoid main(String[] arg) {
TestAddress test = new TestAddress();
test.beforeClass();
test.before();
删除
Address a = new Address();
a.setId(1);
test.deleteAddress(a);
增加
Address a = new Address();
a.setName("北京市");
a.setUsername("张三");
a.setCode("010");
test.addAddress(a);
修改
Address a = new Address();
a.setId(1);
a.setName("北京市");
a.setUsername("张三");
a.setCode("010");
test.updateAddress(a);
查询
test.queryAddress();
test.after();}
publicvoid beforeClass(){
session =
new AnnotationConfiguration().configure("join.cfg.xml").buildSessi onFactory().openSession(); }
publicvoid before(){
session.beginTransaction();}
publicvoid after(){
session.getTransaction().commit();}
publicstaticvoid afterClass(){
4.2顾客Customer的增加、删除、修改、查询
static Session session;
static List
static List
publicstaticvoid main(String[] arg) {
TestCustomer test = new TestCustomer();
test.beforeClass();
test.before();
// 删除
Customer a = new Customer();
a.setId(1);
test.deleteCustomer(a);
//增加
Customer a = new Customer();
a.setCustomername("张三");
a.setUsername("Tong");
a.setPassword("123456");
a.setPhone("1350000000000");
a.setSex("男");
a.setAge(32);
test.addCustomer(a);
//修改
Customer a = new Customer();
a.setId(1);
a.setName("北京市");
a.setUsername("张三");
a.setCode("010");
test.updateTestCustomer(a);
//查询
test.queryCustomer("张三");
test.after();}
4.3商品Product增加、删除、修改、查询
static Session session;
static List
static List
publicstaticvoid main(String[] arg) {
TestProduct test = new TestProduct();
test.beforeClass();
test.before();
//删除
Product a = new Product();
a.setId(1);
test.deleteProduct(a);
//增加
Product a = new Product();
a.setName("衣服");
a.setContent("漂亮的上衣");
a.setMoney(38.99);
a.setPicture("图片路径");
a.setCode("1000001");
test.addProduct(a);
五.总结
在初步学习了hibernate之后,使我明白了hibernate是一个怎样的软件。hibernate是一个比较独立的框架,它不需要太多其他软件的支持。hibernate是一个开放源代码的关系映射框架,它对JDBC进行了非常轻量级的对象封装。这样的好处是,它可以让程序员使用Java中常用的对象编程思维来对数据库进行增、删、改、查等操作。hibernate具有很好的兼容性。它可以在多个客户端中运行,也可以很好的兼容各种的操作系统。hibernate可以在Java的客户端中使用,当然也可以在Servlet/JSP的Web应用中使用……在开始学习hibernate逆向工程,开始也觉得无从下手,难以捉摸。尤其有很多看不懂的英文,毕竟英语不是自己的母语,而且本身英语也不是太好,有的时候的一些错误提示,或者一些对话框总是要找一些翻译软件去翻译。所以如果有其他人想学hibernate,希望能克服英文的难关,同时也要有耐心,毕竟没有什么东西是可以一天就能学成的。而且hibernate是相对比较简单的软件,还算比较好学。希望大家能一起学习,共同进步。
课程内容 1.面向接口(抽象)编程的概念与好处 2.IOC/DI的概念与好处 a)inversion of control b)dependency injection 3.AOP的概念与好处 4.Spring简介 5.Spring应用IOC/DI(重要) a)xml b)annotation 6.Spring应用AOP(重要) a)xml b)annotation 7.Struts2.1.6 + Spring2.5.6 + Hibernate3.3.2整合(重要) a)opensessionInviewfilter(记住,解决什么问题,怎么解决) 8.Spring JDBC 面向接口编程(面向抽象编程) 1.场景:用户添加 2.Spring_0100_AbstractOrientedProgramming a)不是AOP:Aspect Oriented Programming 3.好处:灵活 什么是IOC(DI),有什么好处Dependecy Injection (依赖注入)依赖UserDAO a)IOC (inversion of control)控制反转,交给容器来控制 1.把自己new的东西改为由容器提供 a)初始化具体值 b)装配 2.好处:灵活装配 Spring简介 1.项目名称:Spring_0200_IOC_Introduction
2.环境搭建 a)只用IOC i.spring.jar , jarkata-commons/commons-loggin.jar 3.IOC容器 a)实例化具体bean b)动态装配 4.AOP支持 a)安全检查 b)管理transaction Spring IOC配置与应用 1.FAQ:不给提示: a)window – preferences – myeclipse – xml – xml catalog b)User Specified Entries – add i.Location: D:\share\0900_Spring\soft\spring-framework-2.5.6\dist\resources\sprin g-beans-2.5.xsd ii.URI: file:///D:/share/0900_Spring/soft/spring-framework-2.5.6/dist/resource s/spring-beans-2.5.xsd iii.Key Type: Schema Location iv.Key: https://www.wendangku.net/doc/7b7840697.html,/schema/beans/spring-beans-2.5.xsd 2.注入类型 a)Spring_0300_IOC_Injection_Type b)setter(重要) c)构造方法(可以忘记) d)接口注入(可以忘记) 3.id vs. name a)Spring_0400_IOC_Id_Name b)name可以用特殊字符 4.简单属性的注入 a)Spring_0500_IOC_SimpleProperty b) spring4.x + hibernate4.x 配置详解 关于spring和hibernate的使用以及特征等等,在此不再啰嗦,相信大家也都知道,或者去搜索一下即可。 本篇博文的内容主要是我最近整理的关于spring4.x 和hibernate 4.x 相关配置和使用方式,当然spring3.x以及hibernate4.x也可以借鉴。 首先是配置文件web.xml 增加以下代码即可 spring4.x + hibernate4.x 配置详解
SpringMVC框架搭建说明 Spring4.1.4 + hibernate4.3.8 1、web.xml配置 程序运行时从web.xml开始,加载顺序为:context-param -> listener -> filter ->structs (如果使用structs的话)-> servlet 如下为web.xml的配置说明
3. hibernate.hbm2ddl.auto : 在SessionFactory 创建时,自动检查数据库结构,或者将数据库schema 的DDL 导出到数据库。使用create-drop 时,在显式关闭SessionFactory 时,将删除掉数据库schema。 例如:validate | update | create | create-drop create :如果没有表就创建 update :如果表结构更新,就更新 validate :每次插入表的时候看看表结构有没有更新。 理论上是先建类后建表:这个时候只要你的类建好了,可以跨数据库。 实际中先建表比先建类多,建好表以后要对数据库进行优化,比如建索引,建试图,各种各样的优化。 project\etc目录下面有很多示例性的文档,log4j的文档就在那个下面。 SessionFactory sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); SessionFactory的建立是很耗费时间的,应该像连接池一样,只建立一次,以后要用就直接从那用。 Hibernate文档建议我们自己写一个辅助类,用单例来做。 JUnit的一个bug: @BeforeClass public static void beforeClass() { sessionFactory = new AnnotationConfiguration().configure().buildSessionFactory(); } 在这句话的时候 配置文件如果有的时候写错了,她悄悄把错误隐藏起来了。 解决的方法:可以对这句话加try catch块 8.表名和类名不一致的时候: @Entity @Table(name="_teacher")
第一次课: 持久化:就是把瞬时状态的数据转变为持久化状态的数据,这一个过程就是持久化。 (java中内存分为:栈(变量,方法,形参都是在栈上),堆(new出来的对象在堆上)) 1)瞬时状态:刚new出来,在内存中存在的对象就是瞬时状态的。如果程序结束,对象就会被回收。 2)持久化状态:在磁盘或者是数据库中存在的数据就是持久状态。 Hibernate是什么? 1)是一个优秀的持久化框架,对jdbc进行进一步的封装。(hibernate,ibatis )。 2)是一个ORM (Object relation mapping ). Mysql,oracle,access 是关系型数据库 = hibernate操作的是对象。 使用hibernate的步骤:1)新建项目 2)引入jar包(hibernate最少依赖8个jar包) 3)新建 hibernate配置文件(hibernate.cfg.xml) ,放在src根目录下面。 用于数据库的配置信息。
Hibernate Annotation 使用hibernate Annotation来映射实体 准备工作 下载 hibernate-distribution-3.3.2.GA hibernate-annotations-3.4.0.GA slf4j 导入相关依赖包 Hibernate HOME: \hibernate3.jar \lib\bytecode(二进制) \lib\optional(可选的) \lib\required(必须的) 导入required下的所有jar包 antlr-2.7.6.jar commons-collections-3.1.jar dom4j-1.6.1.jar hibernate3.jar javassist-3.9.0.GA.jar jta-1.1.jar slf4j-api-1.5.10.jar slf4j-log4j12-1.5.10.jar log4j-1.2.14.jar mysql.jar ---Annotation包 ejb3-persistence.jar hibernate-annotations.jar hibernate-commons-annotations.jar
简单的例子,通过annotation注解来映射实体PO 1、建立(Java Project)项目:hibernate_0100_annotation_HelloWorld_default 2、在项目根下建立lib目录 a)导入相关依赖jar包 antlr-2.7.6.jar commons-collections-3.1.jar dom4j-1.6.1.jar ejb3-persistence.jar hibernate-annotations.jar hibernate-commons-annotations.jar hibernate3.jar javassist-3.9.0.GA.jar jta-1.1.jar log4j-1.2.14.jar mysql.jar slf4j-api-1.5.10.jar slf4j-log4j12-1.5.10.jar 3、建立PO持久化类cn.serup.model.Teacher 内容如下 package cn.serup.model; import javax.persistence.Entity; import javax.persistence.Id; //@Entity表示该是实体类 @Entity public class Teacher { private int id ; private String username ; private String password ; //ID为主键,主键手动分配 @Id public int getId() { return id; } public void setId(int id) { this.id = id;
说明: 本文对hibernate的一对多、多对一、多对多的关联 示例代码是Order类和OrderItem类的一对多的关系 1.一对多 1.1注解方式: @OneToMany 代码示例如下: 双向关联,维护端在“多”的一端 Public class Order implements Serializable { Private Set
注解整理笔记 @是java中的注解。 JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 1@SuppressWarnings("serial") 实体类注解例子 2@Entity 3@Table(name = "T_BASE_ROLE") 5@Cache(usage = CacheConcurrencyStrategy.NONSTRICT_READ_WRITE, region = CacheConstants.HIBERNATE_CACHE_BASE) //jackson标记不生成json对象的属性 4@JsonIgnoreProperties (value = { "hibernateLazyInitializer" , "handler","fieldHandler" ,"resources","users"}) public class Role extends BaseEntity implements Serializable { 6@Id 7@GeneratedV alue(strategy = GenerationType.AUTO) 8@Column(name = "ID") public Long getId() { return id;} @Excel(exportName="记录创建者", exportFieldWidth = 30) protected String createUser; 9@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+08:00") @Column(name = "CREATE_TIME", updatable = false) 10@Temporal(TemporalType.TIMESTAMP) public Date getCreateTime() { return createTime;} 11@ManyToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}, fetch = https://www.wendangku.net/doc/7b7840697.html,ZY) 12@JoinTable(name = "T_BASE_ROLE_RESOURCE", joinColumns = { @JoinColumn(name = "ROLE_ID") }, inverseJoinColumns = { @JoinColumn(name = "RESOURCE_ID") }) 13@OrderBy("id") public List
Struts2框架 一、简介 Struts2是一个相当强大的Java Web开源框架,是一个基于POJO的Action 的MVC Web框架。它基于当年的WebWork和XWork框架,继承其优点,同时做了相当的改进。 1、Struts2基于MVC架构,框架结构清晰,开发流程一目了然,开发人员可 以很好的掌控开发的过程。 2、使用OGNL进行参数传递。OGNL提供了在Struts2里访问各种作用域的 数据的简单方式,你可以方便的获取Request、Attribute、Application、 Session、Parameters中的数据。大大简化了开发人员在获取这些数据是的 代码量。 3、强大的拦截器。Struts2的拦截器是一个Action级别的AOP,Struts2中的 许多特性都是通过拦截器来实现的,例如异常处理、文件上传、验证等。 拦截器是可配置与重用的,可以将一些通用的功能如:登录验证、权限 验证等置于拦截器中以完成了系统中的权限验证功能。 4、易于测试。Struts2的Action都是简单的POJO,这样可以方便的对Struts2 的Action编写测试用例,大大方便了Java Web项目的测试。 5、易于扩展的插件机制。在Struts2添加扩展是一件愉快而轻松的事情,只 需要将所需要的Jar包放到WEB-INF/lib文件中,在Struts.xml中做一些 简单的设置就可以实现扩展。 6、模块化管理。Struts2已经把模块化作为了体系架构中的基本思想,可以 通过三种方法来将应用程序模块化:将配置信息拆分成多个文件把自包 含的应用模块创建为插件创建的框架特性,即将于特定应用无关的新功 能组织成插件,以添加到多个应用中去。 7、全局结果与声明式异常。为应用程序添加全局的Result,和在配置文件中 对异常进行处理,这样当处理过程中出现指定异常时,可以跳转到特定 页面。 二、Struts2的工作机制 在Struts2框架中的处理大概分为: 1、客户端初始化一个指向Servlet容器(如Tomcat)的请求; 2、这个请求经过一系列的过滤器(Filter)(这些过滤器中有一个叫做 ActionContextCleanUp的可选过滤器,这个过滤器对于Struts2和其他框 架的集成很有帮组,例如:SiteMeshPlugin); 3、接着FilterDispatcher被调用,FilterDispatcher询问ActionMapper来决定 这个请求是否需要调用某个Action; 4、如果ActionMapper决定需要调用某个Action,FilterDispatcher把请求的 处理交给ActionProxy; 5、ActionProcy通过Configuration Manager询问框架的配置文件,找到需要 调用的Action类; 6、ActionProxy创建一个ActionInvocation实例。 7、ActionInvocation实例使用命令模式来调用,在调用Action的过程前后,
整合SSH框架 整合框架版本:hibernate-distribution-3.6.0.Final-dist + spring-framework-2.5.6.SEC01-with-dependencies + struts-2.1.8.1 一、搭建工具 Windows 、Tomcat 6.0+ 、MyEclipse、SQLServer2008 R2 、Google 二、创建工程 新建WEB项目工程(MyEclipse),包含web.xml配置文件。 三、添加框架环境Junit4 右击新建的项目,选择Build Path —> Add Library —> Junit —> 选择Junit4 —> 确定完成单元测试的添加。 四、添加框架环境Struts2 1.解压struts- 2.1.8.1 ,如下图所示: 可在apps文件里,随机选择一个.war文件解压,到WEB-INF→lib下的基础jar文件:
复制黏贴添加到项目工程的lib下。也可将lib下的全部jar(71个)都复制到项目中来,不过很多用不到。我们崇尚即用即加的原则…… 2. 配置struts.xml和web.xml文件,如下: web.xml:
1. Hibernate Annotation关系映射有下面几种类型: 1)一对一外键关联映射(单向) 2)一对一外键关联映射(双向) 3)一对一主键关联映射(不重要,有需要看下文档即可) 在实际中很少用,使用注解@PrimaryKeyJoinColumn 意思是说,我的主键去参考另外一张表中的主键,作为我的主键,但是在我测试使用 注解一对一主键关联映射,在生成表的时候,数据库中并没有生成关联,使用XML 映射可以生成。Annotation注解一对一主键关联映,有些bug。不过没空去研究它。 因为在实际开发中一对一很少用。在实际开发中我机会没有用过,主键关联就更少了 4)多对一关联映射(单向) 5)一对多关联映射(单向) 6)一对多关联映射(双向) 7)多对多关联映射(单向) 8)多对多关联映射(双向) 2.介绍各种映射用法 1)一对一外键关联映射(单向)Husband ---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} … } public class Wife{ } 一对一外键关联,使用@OneToOne,并设置了级联操作 @JoinColum设置了外键的名称为wife_id(数据库字段名),如果不设置,则默认为另一类的属性名+ _id 外键的值是唯一的(unique),不可重复,与另一类的主键一致 2)一对一外键关联映射(双向)Husband <---> Wife public class Husband{ private Wife wife; @OneToOne(cascade=CascadeType.ALL) @JoinColumn(name="wife_id",unique=true) public Wife getWife(){…} ... } public class Wife{ private Husband husband; @OneToOne(mappedBy="wife",cascade=CascadeType.ALL) public Husband getHusband(){…} ... } 一对一双向关联关系,使用@OneToOne 注意:需要加上mappedBy="wife",如果不加上的话,Wife也会生成一个外键(husband_id)。mappedby="wife"需要指向与他关联对象的一个属性(即Husband类里面的wife属性),这里的会在Husband表里面生成个外键wife_id字段,而Wife表里则不会生成。这里Husband作为维护端即主
java hibernate注解简单使用 前提: 这篇对hibernate的注解的一些参数的介绍的不是很不全(通常只是介绍例子中给出的注 解解析),要更完整的了解其中一个注解可以再继续查询这个注解。 这篇更多的是我自己学hibernate的总结,然后把注解列举一下,方便查找。 映射实体类例子 一般文件类DefaultFile @MappedSuperclass @Inheritance(strategy = InheritanceType.TABLE_PER_CLASS) publicclass DefaultFile { // Fields @Id @Column(name = "id", insertable = false, updatable = false) @GeneratedValue(strategy=GenerationType.IDENTITY) privateint id; @Column(name = "name") private String name; @Column(name = "path") private String path; @Column(name = "note") private String note;
@Column(name = "uploadDate", insertable = false, updatable = false) private Timestamp uploadDate; /** * 文件内容,不被映射成column */ @Transient File file; ... } 图片文件类ImageFile @Entity @Table(name = "imageFile") publicclass ImageFile extends DefaultFile { @OneToMany(cascade = CascadeType.ALL,mappedBy="imagefile", fetch = https://www.wendangku.net/doc/7b7840697.html,ZY) private Set