java面试重点总结

反射

重写(覆盖)：父子

重载：一个类内

equals&&hashCode:为什么要同时覆盖？

hashCodP覆盖的主要作用是为了配合基于散列的集合一起正

常运行，这些结合包括；

hashSet,hasMap,HashTable

对集合的操作？

l.hashSet.addiobjecto);

他会先调用这个对象的hashcode()方法，定位到他要放的物理位置

如果该位置上没有元素，则直接把该元素存储在该位置上。

如果该位置有元素，则会调用该对象的equals方法，判断他

们是否相同。

相同，则不存储不相同，则散列到其他地址。

2.hashSet.contains(objecto);

查找一个元素时：首先调用该对象的hashCode方法，若该位置有元素则调用equals方法，否

则不调用。

默认的hashCode是一个本地方法，返回的是一个与地址所对应的值(但不是内存地址)

如果Student覆盖了equalsandhashCode方法

hashSet.add(newstudent(l/zs//))；〃只调用hashCode

hashSet.add(newstudent(2/lsMl);〃只调用hashCode

hashSet.add(newstudent(3,"wv/"));〃只调用hashCode

hashSet.add(newstudent(l,"zs"));〃调用hashCode还要调用ecuals

如果Student覆盖了equals但hashCode返回值相等

hashSet.add(newstudent(l/zs//))；〃只调用hashCode

hashSet.addfnewstudent(2/,Is"));〃只调用hashCode,1次equals

hashSet.add(newstudent{3,"ww"));〃只调用hashCode,2次equals

hashSet.add(newstudent。,"zs"));〃调用hashCodeX次equas

String:

2.html有浏览器解析执行，主要：兼容性问题

css数据与外观分离（主要负责页面的外观）

js:用于与页面交互的脚本语言，在浏览器端执行。

作用：

1.前端验证（验证不通过，浏览器不提交数据到服务器。）

2.ajax核心技术一，用于异步的向服务器发送请求，并动态更新页面。

3.与页而交互，生成一些动态效果（比如：嵌入动态文本于HTML页面）

4.获取浏览器的相关信息。

3.浏览器如何处理URL:http://ip:port/appname/login.do

第一步：服务器查看有没有appname对应的用户存在，若没有返回404,如有则进入下

一步。

第二步：在web.xml中（与appname所对应的），使用"/login.do”与url-pattern进

行匹配

第二步：如果任然没有匹配到，会查询静态资源。

如果找到返回，找不到返回404.

4.get&&post请求

Get:

什么时候采用：表单的默认提交方式，直接在浏览器上输入地址，通过链接访问。

特点：在地址栏会显示数据，请求数据会放在请求资源路径后而，一般用于向服务器获取资

源。

Post:

设置表单为post方式：

特点：数据不会在地址栏显示，数据会存放在实体内容里，一般用于向眼务器发送数据。

二者对比:get的缺点：提交的数据有限制（因为只能存放在请求行之后）

不安全（浏览器地址栏能看到数据）

Post的优点：数据量大（因为存放到实体内容里面）

相对安全（但是实体内容的数据任然没有加密，可以借助工具看到）

5.重定向与转发

重定向：服务器向浏览器发送一个状态码为302及一个消息头location,浏览器会立即向

location所指向的地址发送一个新的请求。

编程：response.sendRedirect（重定向地址）

重定向的特点及需要注意的：

重定向的地址是任意的

浏览器中地址栏的地址会变成重定向的地址

一件事情已经做完了。

由于重定向方式产生了一个新的请求，所以经过一次重定向后，request内的对

象将无法使用。

转发：在同一个应用内部，一个组件将未完成的任务转交给另外一个组件来完成。

编程：request.getRequestDispatcher（"另一个组件的地址。.forward（request,response）;

特点：一件事情未完成

转发的目的地，只能是司一个应用内部

转发时浏览器地址栏的地址没有任何改变。

转发涉及组件之间，可以共享同一个request,response对象。

前后两个页而有数据传递用请求转发（servlet查询出数据，转发到jsp）,没有则用重定向。

要注意的：重定向/转发之前不能有任何的输出（有则报错）。如果缓存中有数据，重定向/

转发之前会清空缓存中的数据。

6.servlet:在服务器上运行的小程序.也是扩展web服务器的一种组件。

组件（程序员写）：组件是符合规范，完成一一定功能，并可以单独部署的软件模块，组件般

不能单独运行，需要依赖容器才能运行。

容器（一般由大厂商提供）：提供组件的运行环境，并且管理组件的生命周期。

Servlet容器：提供servlet运行的环境，并且管理servlet的生命周期，一般常见的web容器:

比如tomcat,除了一个servlet以外，同时也是一个web服务器。（既是servlet容器，又是

web容器）

servlet是运行于servlet容器中，可以被servlet容器动态加载，来扩展服务器的功能，并提供

特定的服务。servlet按照请求/相应的方式工作。

主要作用：web服务器本身没有计算能力，也就谁说，不能处理动态资源的请求。servlet

可以处理动态资源的请求。

Servlet响应用户请求的过程:

浏览器输入一个地址（指向一个servlet）http://ip:port/m/test/login.do

1.浏览器依据ip,端口号连接服务器

2.浏览器将请求数据包按http协议打包成一个http请求数据包

3.服务器“看出来”这个请求要的是一个servlet（web.xml中为url-pattern进行匹配），此

时服务器中的一个负货通讯的模块（一般叫做servlet引擎）会创建

HttpServletRequest实例（HttpServletRequest实际上是一个接口，有服务器提供者实现，该

实例包含了请求数据中的数据）

还创建了HttpServletResponse实例。

4.服务器依据port之后的部分mytest/login.do找到web.xml,依据web.xml中的信息找到对

应的servlet类名。

<servlet>

<servlet-name>UserMgmt</servlet-name>

<servlet-class>web.UserMgmt</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>UserMgmt</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

会查看该servlet有没有对应的实例，如果没有则创建实例，如果有则使用现成实例(此时

可能出现线程安全问题)

//service(HttpServletRequestrequest,HttpServletResponseresponse)

〃对于程序员，就操作这两个对象。

接下来调用service()方法。Service方法里面的代码可以通过HttpServletRequest提供

的方法获取请求中的数据。并且可以将处理之后的结果通过HttpServletResponse提供的方

法设置返回的结果。

5.servlet引擎从HttpServletResponse获取数据，生成http响应数据包，发送给浏览器。

6.servlet生命周期:

核心接口：servlet接口(所有的servlet必须实现该接口)

该接I」主要定义三个方法：

init(ServletConfigconfig):初始化方法ServletConfig:主要用于获取

servlet配置参数。

service(req,res):处理请求(判断get/post请求，调用响应的

doget/dopost)

destroy。:销毁资源容器根据自己的算法，在删除之前调用destory。释放资源。

servlet容器默认调用有参的(GenericServlet类中)

publicvoidinit(ServletConfigconfig){

this.config=config;

init();

)

1.实现servlet接口

2.继承GenericServlet1实现service方法)

3.继承HttpServlet类(币写doGet,doPost方法就行)

默认的init()方法由GenericServlet来实现，如果想自定义自己的初始化过程，可以重写

lnit()(直接写要写的代码)方法或重写init(ServletConfigconfig)(要调用父类的

super.init(config))

7.Why?jsp:因为直接使用servlet生成动态页面过于繁琐，使用jsp生成动态页面更方便。

(jsp不需要编译，直接打包，就可以运行)

Jsp(javaserverpage):服务器端动态页面生成技术，主要组成部分是html元素，以及少量java

代码,

Jsp:如何运行

当访问某个Jsp文件时,jsp引擎(servlet容器中的某一个特点的模块)会将.Jsp文件转换

为.Java文件(Java就是一个servlet)然创建其实例，并调用其service()方法。

Jsp>java

对于java代码片段<%%>:把代码直接放在service。方法中

对于java表达式<%=%>:放到service。方法中，使用out.prin()输出

对于html：放到service。方法中，使用out.write()输出

注:print(null)输出null,write(null)输出"

对于<%!Stringline="hellowordl"%>:声明的变量会作为对应的servlet的属性

力法oooo00OOOOO♦ooooooo―1个独3/1方法

(不建议用，容易导致线程不安全)

8.Session&&cookie

http是无状态的，(可以利用有限的资源为多个客户服务)即：http服务器不记录哪一个浏

览器访问了

要记录状态的情况：比如购物系统，要记录客户端的状态。

Cookie:将用户的状态保存在客户端。

Session将用户的状态保存在服务器端。

Cookie:浏览器访问某个服务器时，服务器会创建一部分数据。(以消息头set-cookie的方式)

发送给浏览器，浏览器会将这部分数据保存下来。当浏览器再次访问该服务器时，将会把这

部分数据发送给服务器。

创建：response.addCookie(…)

查询：request.getCookies()

Cookie限制：

l.cookie只能保存字符串，并且对于中文，需要编码。

2.cookie大小有限制(4k左右)

3.cookie的个数也有限制(本地大约三百)

4.cookie不是很安全

5.cookie可能被用户禁止。

Cookie的时用场合:自动登录，网页换肤，。。。。。。

路径问题:http://ip:port/appname/jsp01/jsp01.jsp

创建cookie时都会有一个默认的path此时为:/appname/jspOl

当请求这个路径之下的，都会把cookie带过去egg:/appname/jspOl/acd/cde.jsp

/appname/jspOl.jsp则不会。

Session:浏览器访问服务器时，服务器会创建一个对象(session对象)，同时，还会生成一个

标识该对象的唯一字符串(sessionlD)，服务器在默认的情况下使用cookie机制将sessionlD

发送到浏览器，浏览器下次访问时，会将sessionlD携带到服务器，服务器使用sessionlD查

找对应的session对象。

用户禁止cookie:

使用：URL重写机制来解决，url+sessionlD

即在访问某个需要session机制支持的组件时，不需要在浏览器地址栏输入地址，而是

通过服务器生成的URL地址来访问。

response.encodeURL(uH)〃在链接，表单提交时使用。

response.encodeRedirectURL(url)//在重定向时，使用

session优点：

相对于cookie机制，安全，存放的数据可以是对象，存放的数据量也更大。

缺点：

所有的数据都存在服务器端，服务器端压力比较大，一般会采取激活，钝化机制，将

session当中的数据临时保存到文件或者数据库。

Servlet线程安全问题：在馈认情况下，容器只会为某个servlet维护一个实例，当多个请求到

达容器时，有可能多个线程会访问同一个实例。

如何解决：

1.加锁。比如可以使用synchronized对方法或者代码块加锁。

2.实现SingleThreadModel接口(servlet容器会为每一个请求创建一个与之对应的

实例，不建议使用，因为这样会创建大量的servlet对象)

3.避免使用全局变量(实例变量)，使用局部变量。

4.尽量不对属性值进行修改(即：尽量不要对全局变量值，进行修改。)

Ajax:通过浏览器内置的XMLR^quest异步的向服务器发送请求，服务器在处理完请求后，返

回数据给XMLRequest,通过JavaScript可以获取XMLHttpRequest中的数据，然后使用该数据

更新页面。

编程：

1.获耳乂XMLHttpRequest对象

2.使用XMLHttpRequest对象

1)url

2)XMLHttpRequestopen('get/post',url,true)

3)XMLHttpRequestonReadyStateChange=funl;

〃注册回调函数，用于处理服务器请求。

4)XMLHttpRequestSend()

3.在服务器端编写相应代码处理请求。再服务器端，一般不会返I可完整的页面，只需要返回

部分数据。

4.在回调函数中，通过XMLHttpRequest获取数据，然后更新页面。

El&ajstl自定义

EL即ExpressionLanguage(表达式语言)

EL的语法:${ELexprission)

${}或${bean['na-ne']}

JSTL(JSPStandardTagLibrary)是JSP标准标签库

自定义el函数：

L写一个java类，定义一个或者多个publicstatic方法，在方法中实现函数逻辑。

2.在.tld文件中描述该函数。(在jstl库中，找至Ufn.tld参考其格式)

3.在jsp页面中，使用taglib指令导入相应的函数。

自定义标签：

<%@tagliburi="/jsp/jstl/core"prefix="c"%>

1.写一个java类，实现SimpleTag接口，或者继承SimpleTagSupport。

2.在java类中，重写doTag()方法，在该方法当中，实现标签的业务逻辑。

3.在.tld文件当中，描述标签

4.在jsp页面中，使用taglib指令导入相应的标签。

OGNL(Object-GraphNavigationLanguage),大概可以理解为：对象图形化导航语言。是一种

可以方便地操作对象属性的开源表达式语言。

过滤器：在servlet规范中定义的一种特殊的类，可以用来拦截服务器调用servlet的过程。

编程：1.写一个类，实现impl2mentsFilter■接口

2.在doFilter()方法里,实现过滤的逻辑。

3.在web.xml中配置过滤器

<filter>

<filter-name>CommentSizeFilter</filter-name>

<filter-class>web.CommentSizeFilter</filter-class>

</filter>

<filter-mapping>

<filter-name>CommentSizeFilter</filter-name>

<url-pattern>/comment</url-pattern>

</filter-mapping>

过滤器的优先级：按配置的先后顺序执行

SSH内容：

Struts2负责显示层和控制层,Spring负责业务层,hibernate负责持久化层。

Struts2:工作流程

浏览器1请求过滤器2调用action3调用业务类

action4转发Jsp5应答浏览器

l.Action中获取jsp的值：

1.页面中name的属性和action中的属性必须保持一致。

2.Action中的属性必须有get和set方法。

3.满足这两个条件就实现了属性驱动。

实现原理：

struts2会拦截器

publicclassActionMappingParametersInteceptorextendsParameterslnterceptor

根据反射的机制，调用对应action的对应set方法，获取页面表单的值。

模型驱动：

publicclassModelActionextendsActionsupport

implementsModelDriven<User>{

privateUseruser=newUser();

©Override

publicUsergetModel(){

returnuser;

)

过程为：当浏览器提交ModelAction.action请求时，先经过拦截器。其中有一个拦截器为

ModelDrivenlnterceptor,从这个源代码可以看出，这个拦截器的作用就是获取实现了

ModelDriver接口的action的模型驱动。在这里为user。然后把模型驱动利用push方法压入

到栈顶。这样我们就能直接通过属性进行回显和赋值了。

通过这个图也可以看出模型驱动的拦截器在参数拦截器前面，也就是先把模型驱动压入栈

顶，再进行赋值。

模型驱动过程：当用户触发UserAction动作时，ModelDriven拦截器会调用相关UserAction对

象的getModel（）方法,并将返回值<User实例）压入到valueStack栈中，接下来parameters

拦截器将把表单中的字段映射到valuestack栈顶对应的各个属性当中。因为此时栈顶是刚刚

被压入的模型，所以模型被填充。

不能转换的怎么办：比如struts2要求的日期是：yyyy-mm-dd

1、但如果是yyyyMMdd怎么办？

2、写一个java类，这个类必须继承DefaultTypeConverter或者实现

TypeConverter接口。

3、配置自定义的类型转换器：

L基于字段（局部的）

创建一个属性文件actionName（根据action类名来写）

-perties,该文件需要与相对应的动作类放在同一目录下。

Egg:UserActioi—perties中

createTime=com.lyg.converter.DateConverter

2.基于类（全局的）

在根目录下：创建xwork-perties

Java.util.Date=com.lyg.converter.DateConverter

2.国际化

L定义不同的资源文件

resources_en_US.properties

resources_zh_CN.properties

perties（默认）

2.在struts.xml中配置（constantname="struts.cuttom.il8.re$ourse"value=w.resources,,>

通过ieinternet选项修改语言来测试。

2.自定义拦截罂：拦截器是ACP的一种实现

所有的拦截器都实现了Interceptor接口，或者继承了Interceptor接口扩展类实现类。

重写init（）,intercept。,destroy。方法

intercept。每次请求就执行一次，做相关的处理工作

在struts.xml中配置，注册即：把默认栈加入到自己写的拦截器中

<interceptors>

<!--定义自己的拦截器

（interceptorname="accesslnterceptor"

class="erceptor.Privilegelnterceptor">

</interceptor>

<!--声明拦截器栈-->

<interceptor-stackname="accesslnterceptorStack">

<!-引用自定义的拦截器-->

<interceptor-refname="accesslnterceptor"x/interceptor-ref>

<!-引用struts2内部的拦截器栈->

<interceptor-refname="defaultStack"x/interceptor-ref>

</interceptor-stack>

</interceptors>

使用自己写的拦截器栈：

<default-interceptor-refname="accesslnterceptorStack"x/default-interceptor-ref>

说明：使用拦截器栈。从上面声明部分可以看出,accessInterceptorStack栈既包括了自定义的

拦截器，又包括了struts2内部的拦截器栈。

拦截器与过滤器的区别；

1）拦截器是基于Java反射机制的，而过滤器是基于接口回调的。s

2）过滤器依赖于Servlet容器，而拦截器不依赖于Servlet容器。

3）拦截器只能对Action请求起作用，而过滤器可以对所有请求起作用。

4）拦截器可以访问Action上下文、值栈里的对象，而过滤器不能。

3.文件上传

4.struts2手工验tit&&xml验证

Get/set获取数据验证:

publicvoidvalidate。｛｝这是一个默认的实现，子类应该覆盖整个方法去完成验证逻辑，执行

后filedError为空，特•执行action中的处理方法。

针对所有业务方法:validate。

针对某一个业务方法:validateLogin（）

4.ognl对象导航语言struts2默认表达是语言

#访问OGNL上下文和action上下文

//request.username等彳介于request.getAttribute（//usernamew）

访问根元素则不需要

%｛｝告诉环境｛｝里面的是ognl表达式。

$：用于在国际化资源文件中，引用OGNL

用于在struts.xml配置文件中，引用OGNL表达式。比如:ab:.jsp?username=$｛username｝

5.回显

回显是用栈顶元素值回显。

方法「要么修改压入到栈顶元素的属性值。

方法二：要么删除栈顶元素，压入新构外的对象。

注意：不能使用赋值因为赋值改变的是引用，不会改变值栈的值。

6.处理表单重复提交

1.在表单中增加隐藏域:<s:token></s:token>

2.在默认拦截器栈中加入，令牌拦截器并配置针对的方法.（修改默认拦截器）

3.在struts.xml中增加一个返回结果类型result

<resultname=,/invalid.token,/>abc.jsp</result>表单重复摄交后转到的页面

7.valueStack值栈

6.ValueStack内存结构图

OgnIValueStack包含：

一个root（对象栈）>ArrayList

一个context--0Map（跟确切地说是一个ognlcontext）

Ognlcontext:包含

一个默认的顶层对象root（是OgnIValueStack中root对象的一个拷贝）

此处的值：不需要#直接通过元素名访问。

一个m叩对象

此处的值：需要#访问。

Valuestack在ActionContext中，ffoActionContext在ThreadLo仕I中，所以可以保证数

据的安全性。

Hibernate:

Udbc与hibernate比较：

Jdbc:优点效率高，连接池代码繁琐，没有数据缓存。

Hibernate:优点面向对象编程，数据缓存

提出了缓存机制，这样可以使访问数据的效率提高很大。

缺点：大量数据的条件下不适合，

程序员对hibernate生成的sql语句不可控。对于sql优化要求很高的项目中，不适合。

2.对象关系映射(ObjectRelationalMapping,简称ORM)

是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。

3.理解sessionFactory

1.在sessionFactory中存放着配置文件和所有的映射文件。

2.sessionFactory是一个重量级的类。

3.一个数据库只能有一个sessionFactory。

4.一个配置文件只能连接一个数据库

5.只要创建了sessionFactory,表就创建完了

6.sessionFactory存放的数据是共享的，但这个类的数据本身是线程安全的。

7.sessionFactory是•个接口，其实现类是：sessionFactorympl

SessionFactory线程安全的

Session线程不安全

采用getCurrentSession。创建的Session会绑定到当前的线程中去、而采用OpenSessionO

则不会。

采用getCurrentSession。创建的Session在commit或rollback后会自动关闭,采用

OpenSessionO必须手动关闭。

4.对象的状态

简单理解：内存中有两个又域一个区域与一般内存一样另一个是hibernate内存区域

位于一般内存区域的对象：临时对象

位于hibernate内存区域的对象：持久化对象

处于hibernate内存中的数据被清除后，被清除的对象叫做游离对象。

持久化对象有3种状态：

持久化状态(Persist):

Session的save方法把临时对象转变为持久化对象。

Session的load()或get。方法返回的对象总是处于持久化状态。

Session的update(),saveOrUpdate()方法使游离对象转变为持久化对象。

当一个持久化对象关联一个临时对象，在允许级联保存的情况下，session在清理

缓存时会把这个临时对象也转换为持久化对象。

OID不为null(oid对象标识符)

位于Session缓存中

持久化对象和数据库中的相关记录对应

Session在清理缓存时，会根据持久化对象的属性变化，来同步更新数据库

在同一个Session实例的缓存中，数据库表中的每条记录只对应唯一的持久化

对象

临时状态(transient);

当通过new语句创建了一个java对象，它处于临时状态。此时不和数据库中的

任何记录对应。

在使用代理主键的情况下,OID通常为null

不处于Session的缓存中

在数据库中没有充应的记录

游离状态(Detached)

当调用session的close。方法时，session的缓存被清空，缓存中的数据所有持久化数据

都变为游离对象。如果在应用程序中没有引用变量引用这些游离对象，它们就会结束生

命周期。

Session的evict。方法能够从缓存中删除一个持久化对象，使他变成游离状态。当

session的缓存保存了大量的持久化对象，会消耗许多内存空间，为了提高性能，可以

考虑调用evict()方法，从缓存中删除一些持久化对象。

OID不为null

不再处于Session的缓存中

一般情况需下，游离对象是由持久化对象转变过来的，因此在数据库中可能还存在

与它对应的记录

Session缓存存在对应的数据中存在对应的记泉

记泉

临时态nono

持久态yes丽力.也可能没仃

游离态no可能位数据没仃删除）也

可能没仃

Customerc=newCustomer();

session.save(c);//1j久对象，俱数据库中没(i

saveOrllpdate:

该方法同时包含save和update方法，如果参数是临时对象就用save方

法，如果是游离对象就用update方法，如果是持久化对象就直接返回（不执行）。

如果参数是临时对象就用save方法

5.映射关系：

主键产生机制:Increment,Identity,Sequence,。。。。。。。

一对多：classesstudent

Student.java中privateClassesclasses;

Classes.java中privateSet<Student>students;

配置文件：

Student.hbm.xml

<many-to-onename=*'classesMclass=Mlyg-coin.Classes">

<columnname=McidM/>〃外键描述了，通过student建立与classes之间的关系

</many-to-one>

Classes.hbm.xml

<setname=,,students,/inverse=wfalsew>

<key>

<columnname="cid”/>

</key>

<one-to-manyclass=vcom.lyg.Studentn/>//指出Classes和那个对象进彳亍关联。

</set>

多对多：Coursestudent

Student.hbm.xml

<setname=,,courses,/table=wstudent-courseMinverse="false”>

<key>

<columnname=wsidM/>

</key>

<many-to-manyclass=ncom.lyg.Course，^column』‘cid”/>

</set>

Course.hbm.xml

<setname="students“table=wstudent-coursez,inverse=wfalseM>

<key>

<columnname="cid"/>

</key>

<many-to-manyclass="com.lyg.Student"column=,,sid”/>

</set>

一般一对多的涉及到美系的维护：都通过多的一方来维护,避免发出叩date语句

Inverse:不维护关系false维护

Cascade:级联

6.一级缓存&&二级缓存

一级缓存：•级缓存在session中存放存放私有的session级别的缓

存

只要一个对象是持久化对象，数据就在一级缓存中。

把缓存中的数据同步到数据库:session.flushO

把数据库中的数据同步到一级缓存:session.reflush。只能同步一个对象

清空一级缓存:session.clear();

二级缓存：二级缓存在sessionFctory中存放存放共享的sessionFctory级别的缓存

存放很少被修改的数据，数据可以公开的

EhCache,OSCache,JBossCache

查询缓存：依赖于二级缓存，所以必须开启二级缓存才可用。

查询数据时：如果查询缓存存在。则直接返回。否则到数据库查询，然后把查询结果放

在查询缓存。

缓存的作用：

1。减少访问数据库的频率。

2。保证缓存中的对象与数据库中的相关记录保持同步。

For(inti=0;i<10000;i++){

Session.save(object);

)

Hibernate:

Forfinti=0;i<10000;i++){

lf(i%50==0)

Sessionfush();〃同步

Session.clear();〃清空

)

Session.save(object);

7.抓取策略：必须是一个对象操作其关联对象。

当应用程序需要在(Hibernate实体对象图的)关联关系间进行导航的时候，Hibernate

如何获取关联对象的策略，

抓取策略可以在0/R映射的元数据中声明，也可以在特定的HQL或条件查询(Criteria

Query)中重载声明。

连接抓取(Joinfetching)-一次性把两张表的数据查出来

查询抓取(Selectfetching)-一个一个加载，先加载一个，在加载关联的。

子杳询抓取(Subselectfetching)-通过需求分析判断，如果存在子查询，则选择。

批量抓取(Batchfetching)-

8.懒加我

针对数据库中的大数据，不希望特别早的加载到内存中，当使用到的时候在加载。

类懒加载：默认lazy="：rue”只有用session.Ioad()才能懒加我

集合懒加载：

针对一对多或者多对多的情况，加载set集合时决定在什么时候给集合填充数据。

当指定为懒加载时：只有使用到set集合时，他才会发出同语句。

Spring:

1.I0C:控制反转"，不是什么技术，而是一种设计思想，在Java开发中，loc意味着将

你设计好的对象交给容器控制，而不是传统的在你的对象内部直接控制。

由loC容器帮对象找相应的依赖对象并注入，而不是由对象主动去找。

依赖注入(DI):被注入对象依赖loC容器配置依赖对象

所谓loC,对于spring框架来说，就是由spring来负责控制对象的生命周期和对象间的关

系。

所有的类都会在spring容器中登记，告诉spring你是个什么东西，你需要什么东西，然

后spring会在系统运行到适当的时候，把你要的东西主动给你，同时也把你交给其他需

要你的东西。所有的类的创建、销毁都由spring来控制，也就是说控制对象生存周期的

不再是引用它的对象，而是springs对于某个具体的对象而言，以前是它控制其他对象,

现在是所有对象都被spring控制，所以这叫控制反转。

loC的•个重点是在系统运行中，动态的向某个对象提供它所需要的其他对象。这一点

是通过DI(DependencyInjection,依赖注入)来实现的。

控制的什么被反转了？就是：获得依赖对象的方式反转了。

依赖注入的三种配置方式：

1.通过set方式

2.通过构造函数

3通过注解（只能用于引用类型）

利用springioc和di做到了完全面向接口编程。

比如：客户端做到完全面向接口编程。

2.Spring容器加我过程：

l.spring容器关于ioc和di:启动过程•…》

2.加载配置文件，启动spring容器》

3.spring容器会

*如果有bean,则直接会为该bean创建对象

*如果有类扫描的注解解析器，则会按照解析器口勺规则做

4.如果bean中有属性，则调用set方法（构造函数）给属性赋值

或者利用@口6$01^6注解给属性赋值

5.创建对象之后，方法调用之前，会执行init方法,spring容器调用

6.在客户端调用方法

7.执行destroy方法,spring容器调用（针对单例）

8.关闭容播

3.注解：

必须依赖于类中的某个部分

Resourse（name=/,user,/）narre

PrivateUseruser;

name—user”按照user■与容器中的进行匹配。不行报错

不写，则先按照user匹配，不成功在按照类型匹配。再不行报错

4.动态代理：

AOP（面向切面编程）

通过代理模式：把日志，安全检查，权限重用了，做到了代码块的重用。而向切面编程。

代理对象的方法：就是拦截器invoke方法体的内容。

代理对象的方法把目标方法和切面整合在一起了。

Jdk代理：四个条件：目标接口目标类，拦截器，代理类

目标类和代理类实现了共同的接口

拦截器必须实现InvocationHandler接口，而接口中的invoke方法体的内容就

是代理对象方法体的内容。

客户端调用代理对象的方法时,invoke方法执行。

代理对象和目标类实现了共同的接口，且代理类中有目标类的引用。

Cglib代理：

用CGlib生成代理类是目标类的子类。

用CGLib生成的代理类重写了父类的各个方法。

拦截器必须实现Methodinterceptor接口，而接口中的lnte，ceptor方法体的内容

如果bean有代理对象，则返回代理对象，没有则返回原对象。

该目标类实现了接口则spring容器会采用jdk代理，否则cglib

原理：

1.加戡配置文件，启动spring容器。

2.spring容器为bean创建对象

3.解析AOP的配置解析切入点表达式。

4.看纳入spring管理的哪个类和切入点表达式匹配，如果匹配则创建代理对象。（拦截

器由spring内部实现）

5.代理对象的方法=目标方法+通知

6.客户端在context.getBean。时，该目标类实现了接口则spring容器会采用jdk代理,

否则cglib

切入点表达式

expression

确定哪个类可以生成代理对象

切入点表达式：

expression="execution（*com.lyg.aop.xml.PersonDaoImpl.*（..））"

PersonDaoImpI类的所有方法。

代理：通过拦磁器调用方法。。（个人理解）

切而：日志，安全性的框架，权限的检查，总之与业务逻辑无关的都可以是切面。

通知：切面中的方法

Struts2的启动流程；

1.后动tomcat

2.加载web.xml

3.过滤器:StrutsPrepareAndExecuteFilter

4.init（）方法力口载perties,struts-default.xml,struts-plugin.xml,struts.xml

5.静态注入配置文件中的bean

当请求的url来时：

1.调用StrutsPrepareAndExecuteFilter的doFilter。方法

2.把actioncontext放入到ThreadLocal中

把ValueStack放入到ActionContext中

这样保证了值栈中的数据的安全性

3.创舛action（因为是务例所以说现在才创建自己理解）

获取所有的interceptor

4.（也使用了动态代理）

执行所有的拦截港

执行action中的方法

结果集的执行

Spring声明式事务处理

<context:component-scanbase-package="com.Lyg.hibernate.transaction.xml.annotation"></context:comp。

<tx:annotation-driventransaction-manager="transaction«a/?<jger7>

<beanid^transactio^nager"

class="org.springframework.onn.hibernate3.HibernateTransactionManagern>

<propertynar»e/5essio*actory”>

<refbean="sessionFactory"/>

〈/property)

</bean>

<beanid^sessionFactory"class-"org.springframeuork.orm.hibernate3.LocalSessionFactoryBeon">

<propertynane="configlocatwn">

<value>classpath:hibernate.cfg.xml</value>

</property>

</bean>

Spring事务架构：

接口与抽象类的差别，也可以体现出来。

接口platformTransactionManager

publicinterfacePlatfornTransactionHanager{

TransactionstatusgetTransaction(TransactionDefinitiondefirition)throwsTransactionException;

uoidcoimit(Transactionstatusstatus)throwsTransactionException;

uoidrollback(TransactionStatusstatus)throwsTransactionException;

)

AbstractPlatformTransactionManager这个类对接口中的commit和rollback进行了实现，而

getTransaction,因为不同的技术产生事务的方式不•样，所以这里有一•个抽象方法

比如：你用hibernate(HibernateTransactionManage)或者jdbc

(DataSourceTransactionManager)启动事务

publicabstractclassfibstr