关于ssh的工作原理及介绍

struts2

验证机制

1.前端控制，用javascript,ajax等技术进行控制

2.在action里面定义validateXxx方法实现后台验证Xxx指的是执行某个操作的具体方法名称，如add方法，对应的验证函数就是validateAdd方法；

3.利用 Struts2的Validation框架内建校验器，创建对应的验证xml文件，文件位置与action必须在同一个包中,文件名称规则,actionName类名-action配置名称-validation.xml

 

Strust2 核心功能

（1）允许POJO（Plain Old Java Objects）对象 作为Action

（2）Action的execute 方法不再与Servlet API耦合，更易测试

（3）支持更多视图技术（JSP、FreeMarker、Velocity）

（4）基于Spring AOP思想的拦截器机制，更易扩展

（5）更强大、更易用输入校验功能

 

Struts2工作原理

（1） 客户端（Client）向Action发用一个请求（Request）

（2） Container通过web.xml映射请求，并获得控制器（Controller）的名字

（3） 容器（Container）调用控制器（StrutsPrepareAndExecuteFilter或FilterDispatcher）。在Struts2.1以前调用FilterDispatcher，Struts2.1以后调用StrutsPrepareAndExecuteFilter

（4） 控制器（Controller）通过ActionMapper获得Action的信息

（5） 控制器（Controller）调用ActionProxy

（6） ActionProxy读取struts.xml文件获取action和interceptor stack的信息。

（7） ActionProxy把request请求传递给ActionInvocation

（8） ActionInvocation依次调用action和interceptor

（9） 根据action的配置信息，产生result

（10） Result信息返回给ActionInvocation

（11） 产生一个HttpServletResponse响应

（12） 产生的响应行为发送给客服端。

 

Hibernate配置的常用属性

一对一配置

employee

一对多配置

        

        

        

                 

多对一配置

对象在Hibernate中的状态

1.临时状态

普通的Java对象，只是一个携带信息的载体没与session实例关联，没与数据库中记录关联

2.持久状态

持久实例在数据库中有对应的记录， 并拥有持久化标识，持久实例可能是刚刚被保存，或刚刚被加载的数据

3.脱管状态

持久对象关联的Session关闭后，对象变为脱管

hibernate的JavaBean有三种状态，临时状态，持久状态，游离状态。对象通过new关键字实例化后就是临时状态，通过save,saveUpdate等方法存到数据库中，且session未关闭，就是持久状态，当session关闭，就是游离状态了。

加载策略

1 立即检索：立即检索的时候需要在配置文件添加属性lazy="false".当Hibernate在从数据库中取得字段值组装好一个对象后，会立即再组装此对象所关联的对象，如果这个对象还有关联对象，再组装这个关联对象；对于一对一和多对一的多的这段默认是采用立即加载，所以不需要配置；多对多和一对多就要配置lazy= "false"。
2 延迟加载：延迟加载不同，当组装完一个对象后，不立即组装和它关联的对象。 多对多和一对多默认采用延迟加载，一对一和多对一想实现延迟加载得配置lazy= "true"。
3 预先抓取 ：Hibernate 2.x版本：outer-join="true" Hibernate 3.x版本：fetch="join"。和立即检索相比，预先抓取可以减少SQL语句的条数，提高查询速度。
4 批量加载 ：批量加载总是和立即加载或者延迟加载联系在一起的，分别为批量立即加载和批量延迟加载。

加载策略

1.一对一默认立即加载、一般不改动

2.一对多默认延迟加载，通过设置lazy=”false”、或fetch=”join”实现立即加载，但一般一对多尽量设成lazy=”true”，当要实现立即加载时通过HQL语句的预先抓取join fetch实现

3.多对一默认立即加载，通过设置lazy=”false”或fetch=”join”实现立即加载

8、lazy=”false”与fetch= “join”的区别

1、lazy=”false”，立即加载，一次只查一个表。产生语句过多，如果数据多的话查询效率较低

2、fetch=”join”,使用连接查询，减少查询次数，提高查询效率

spring的作用

1. 提供一个MVC Web的框架，作为容器管理系统

2. IoC/di ：控制反转/依赖注入

3. AOP面向切面编程

 

spring 的优点
1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 
2.可以使用容易提供的众多服务，如事务管理，消息服务等 
3.容器提供单例模式支持 
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 
5.容器提供了众多的辅助类，能加快应用的开发 
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 
7.spring属于低侵入式设计，代码的污染极低 
8.独立于各种应用服务器 
9.spring的DI机制降低了业务对象替换的复杂性 
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部。

 

 

IOC容器：就是具有依赖注入功能的容器，是可以创建对象的容器，IOC容器负责实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。通常new一个实例，控制权由程序员控制，而"控制反转"是指new实例工作不由程序员来做而是交给Spring容器来做。。在Spring中BeanFactory是IOC容器的实际代表者。

DI(依赖注入Dependency injection) ：在容器创建对象后，处理对象的依赖关系。依赖注入spring的注入方式：

set注入方式

静态工厂注入方式

构造方法注入方式

基于注解的方式

 

 

 

10、介绍spring AOP利用何机制

代理机制

Spring提供的自动代理机制
1、使用BeanNameAutoProxyCreator 
Spring提供的BeanNameAutoProxyCreator类允许我们通过Bean的name属性来指定代理的Bean。它暴露了java.lang.String[]类型的
beanNames和 interceptorNames属性。beanNames可以指定被代理的Bean名字列表，支持“*”通配符，例如“*DAO”表示所有名字以“DAO”结尾的Bean。interceptorNames指定通知（Advice）列表，或者通知者（Advisor）列表。 
2、使用DefaultAdvisorAutoProxyCreator 
DefaultAdvisorAutoProxyCreator允许我们只需定义相应的Advisor通知者，就可以完成自动代理。配置好DefaultAdvisorAutoProxyCreator受管Bean后，它会自动查找配置文件中定义的Advisor，并将它们作用于所有的Bean。

Spring AOP部分使用JDK动态代理或者CGLIB来为目标对象创建代理。（建议尽量使用JDK的动态代理）

如果被代理的目标对象实现了至少一个接口，则会使用JDK动态代理。所有该目标类型实现的接口都将被代理。若该目标对象没有实现任何接口，则创建一个CGLIB代理。 

如在jdk中的java.lang.reflect.Proxy的动态代理机制是spring框架中AOP机制的雏形。很好的理解了jdk的代理是理解springAOP的关键。

Proxy机制在《设计模式》里的解释是：为其他对象提供一种代理以控制对这个对象的访问。在Proxy的机制中，要搞清楚三个对象的关系 源目标，代理目标，控制动作。

代理的目的就是在访问源目标的时候要首先访问代理目标，在代理目标里我们会进行额外的动作。

在jdk中 代理目标 Proxy 控制动作是 InvocationHandler。在jdk中代理的访问是基于接口的，Proxy和Source要实现同一个接口，也就是说他们有着共同的方法，在调用proxy的方法的时候，他会将方法传入到InvocationHandler中的invoke()里，在这里我们可以实现我们的对源目标方法访问的控制。

通过代理，我们可以对源目标不做任何修改，在他的方法执行的前后插入我们的代码。这些插入的代码就是我们经常用的业务：比如 日志 权限控制。

我理解的aop就是将核心业务和常用业务剥离开，而同时又要把常用业务无缝的包在核心业务外面，这个就是Proxy机制应用的典型的环境。

在spring中常用的业务被抽象成为切面（Aspect），具体的动作被成为通知（Advice），要把这些业务的方法放到我们的核心业务的具体的方法周围（前，后，异常或者引入spring总共提供了五种插入方式）。常用业务方法和核心业务方法的关系就是连接点（JointPoint）。一系列的连接点就是切面（PointCut）。

在sping中aop的设置就和proxy的机制的中三个对象的关系是一一对应的，同时还要加上一个接口，因为jdk的proxy针对接口，而sping的aop是通过前者实现。

所以在配置文件里要配置的

1 proxy

2 sourceTarget

3 Interface

 拦截器（advice advisor 拦截器三种）

因为正常情况下，应该是一个目标一个代理，如果目标很多的话，将会有N多的代理要设置，这样将是一个很烦的过程。在spring里面提供了动态代理的机制，后面会专门讲。

在jdk中proxy是直接new出来返回，spring中proxy也是直接在配置文件中写，比较常用的是ProxyFactoryBean，他实现了接口FactoryBean接口。这个接口的本质也是一个代理，他会根据传进的参数自动生成所要的类返回，通俗的讲就是，虽然他也是个bean，但是通过工厂的getBean方法得到的bean将会根据自己的参数而定。在sping的core中我会在详细说明的，用在这里真是恰到好处。

这样就可以为每个目标针对相应的接口创建相应的动态代理。然后为这个代理指定目标和拦截器（advice）。

这里还有解释一个概念：Advisor包括一个通知和一个切入点。

我们刚才说的是设置的都是通知，对于切入点我们指定了接口，这个时候如果要是调用这个接口的方法都会调用通知，所以还有一种就是设置Advisor，Advisor包括一个切入点，PointCut，他会对类和方法进行过滤，只有满足特定的条件的类和特定的方法才可以调用通知，这个时候特定的方法和特定的类 两种可以去类和方法的交集或者并集，可以引入java正则表达式或者perl5正则表达式设置。

Hibernate中，left join、inner join以及left join fetch有何区别？

inner join（内连接） 

left outer join（左外连接） 

right outer join（右外连接） 

full join (全连接，并不常用) 

语句inner join, left outer join 以及 right outer join 可以简写。 
from Cat as cat join cat.mate as mate left join cat.kittens as kitten 

通过HQL的with关键字，你可以提供额外的join条件。 
from Cat as cat left join cat.kittens as kitten with kitten.bodyWeight > 10.0 

还有，一个"fetch"连接允许仅仅使用一个选择语句就将相关联的对象或一组值的集合随着他们的父对象的初始化而被初始化，这种方法在使用到集合的情况下尤其有用，对于关联和集合来说，它有效的代替了映射文件中的外联接 与延迟声明（lazy declarations）. 
from Cat as cat inner join fetch cat.mate left join fetch cat.kittens 

一个fetch连接通常不需要被指定别名, 因为相关联的对象不应当被用在 where 子句 (或其它任何子句)中。同时，相关联的对象 并不在查询的结果中直接返回，但可以通过他们的父对象来访问到他们。 
from Cat as cat inner join fetch cat.mate left join fetch cat.kittens child left join fetch child.kittens 

假若使用iterate()来调用查询，请注意fetch构造是不能使用的(scroll() 可以使用)。fetch也不应该与setMaxResults() 或setFirstResult()共用，这是因为这些操作是基于结果集的，而在预先抓取集合类时可能包含重复的数据，也就是说无法预先知道精确的行数。fetch还不能与独立的 with条件一起使用。通过在一次查询中fetch多个集合，可以制造出笛卡尔积，因此请多加注意。对bag映射来说，同时join fetch多个集合角色可能在某些情况下给出并非预期的结果，也请小心。最后注意，使用full join fetch 与 right join fetch是没有意义的。 

如果你使用属性级别的延迟获取（lazy fetching）（这是通过重新编写字节码实现的），可以使用 fetch all properties 来强制Hibernate立即取得那些原本需要延迟加载的属性（在第一个查询中）。 
from Document fetch all properties order by name 
from Document doc fetch all properties where lower(doc.name) like ''%cats%''

Ajax是如何工作的？

Ajax 基本上就是把 JavaScript 技术和 XMLHttpRequest 对象放在 Web 表单和服务器之间。当用户填写表单时，数据发送给一些 JavaScript 代码而不是 直接发送给服务器。相反，JavaScript 代码捕获表单数据并向服务器发送请求。同时用户屏幕上的表单也不会闪烁、消失或延迟。换句话说，JavaScript 代码在幕后发送请求，用户甚至不知道请求的发出。更好的是，请求是异步发送的，就是说 JavaScript 代码（和用户）不用等待服务器的响应。因此用户可以继续输入数据、滚动屏幕和使用应用程序。 

　然后，服务器将数据返回 JavaScript 代码（仍然在 Web 表单中），后者决定如何处理这些数据。它可以迅速更新表单数据，让人感觉应用程序是立即完成的，表单没有提交或刷新而用户得到了新数据。JavaScript 代码甚至可以对收到的数据执行某种计算，再发送另一个请求，完全不需要用户干预！这就是 XMLHttpRequest 的强大之处。它可以根据需要自行与服务器进行交互，用户甚至可以完全不知道幕后发生的一切。结果就是类似于桌面应用程序的动态、快速响应、高交互性的体验，但是背后又拥有互联网的全部强大力量。

Spring IoC底层运行原理。Spring IoC 反向控制原理

IoC，直观地讲，就是容器控制程序之间的关系，而非传统实现中，由程序代码直接操控。这也就是所谓“控制反转”的概念所在。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象地说，即由容器动态地将某种依赖关系注入到组件之中。
反向控制是Spring框架的核心。通常，应用代码需要告知容器或框架,让它们找到自身所需要的类,然后再由应用代码创建待使用的对象实例。因此，应用代码在使用实例之前，需要创建对象实例。然而，IoC模式中,创建对象实例的任务交给IoC容器或框架(实现了IoC设计模式的框架也被称为IoC容器)，使得应用代码只需要直接使用实例[5]，这就是IoC。相对IoC 而言，“依赖注入”的确更加准确的描述了这种设计理念。所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，形象的来说，即由容器动态的将某种依赖关系注入到组件之中。
任何重要的系统都需要至少两个相互合作的类来完成业务逻辑。通常，每个对象都要自己负责得到它的合作（依赖）对象。你会发现，这样会导致代码耦合度高而且难于测试。使用IoC，对象的依赖都是在对象创建时由负责协调系统中各个对象的外部实体提供的，这样使软件组件松散连接成为可能。

Struts的设计模式

MVC模式: web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

Hibernate工作原理？

通过对象与数据库产生映射，将原来对表的操作变成对对象的操作。

为什么要用：

1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作

hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

hibernate的性能非常好，因为它是个轻量级框架。映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系

Spring的IOC和AOP的理解。

IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection）”。从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态地将某种依赖关系注入到组件之中。

AOP利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了 多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的 逻辑或责任封装起来，比如日志记录，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性

 

spring的主要功能就是：IOC和AOP

IOC：即控制反转，也就是通过一个配置文件在该配置文件中描述了对象和对象的属性信息，通过反射的方法来产生这个对象，并且通过IOC方式，如果配置文件中对象的属性带有值，也会一块为对象附上值，而这些值可以是基本数据类型也可以是引用数据类型，因此IOC也称为依赖注入。可以替代工厂类

AOP：面向切面的编程，在SSH中主要用来是实现动态的代理设计，也就是说将一系列相同的操作封装到一个规则类，在实现这个实现类的时候，先执行这个规则类的初始化操作，在回收进行相应的收尾操作，可以简化ServiceImpl操作。

请简述你对IOC的理解?

所谓的IOC，即控制反转，它的意思个人理解就是说，假设有类A和接口B，现在在类A中我需要调用接口B中的方法，那么最简单的方法就是在类A中对接口B进行实例化出对象来，接口不能自己独立实例化，所以现在假设有子类C，然后直接用子类帮父类进行实例化，然后就可以调用接口B中的方法了，但是这样耦合性过大，依靠IOC的话，就在类A中只定义出接口B，但具体的实现类，是在在spring的配置中，通过注入的方法来为接口B将C注入成B的实例。这就是IOC依赖注入

Hibernate与jdbc的联系和区别

hibernate = jdbc的封装+xml文件。因为hibernate实质是将jdbc进行了轻量级的封装，包括jdbc的数据库连接已经sql语句CRUD封装成了HQL语句，对数据库表的查询变成了对类的查询。

Struts2的工作流程

1 客户端初始化一个指向Servlet容器（例如Tomcat）的请求 

2 这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin） 

3 接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action 

4 如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy 

5 ActionProxy通过Configuration Manager询问框架的配置文件，找到需要调用的Action类 

6 ActionProxy创建一个ActionInvocation的实例。 

7 ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。 

8 一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可 能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2 框架中继承的标签。在这个过程中需要

（欢迎补充，个人一些观点，以及一些资料完善。）