java面试总结-(hibernate ibatis struts2 spring)

说说Hibernate对象的三种状态

Hibernate对象有三种状态，分别是：临时态(Transient)、 持久态(Persistent)、游离态(Detached)。

临时状态：是指从对象通过new语句创建到被持久化之前的状态，此时对象不在Session的缓存中。

处在此状态的对象具备以下特点：

1，不在Session缓存中，不与任何Session实例相关联。

2，在数据库中没有与之对应的记录。

通常在下列情况下对象会进入临时状态：

1，通过new语句创建新对象。

2，执行delete()方法，对于游离状态的对象，delete()方法会将其与数据库中对应的记录删除；而对于持久化状态的对象，delete()方法会将其与数据库中对应的记录删除，并将其在Session缓存中删除。

例如：Object object = new Object();

此时object为临时状态，数据库中没有对应的数据，Session缓存中也没有相关联的实例。

持久化状态：是指对象被持久化到Session对象被销毁之前的状态，此时对象在Session的缓存中。

处在此状态的对象具备以下特点：

1，在Session缓存中，与Session实例相关联。

2，在数据库中有与之对应的记录。

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

通常在下列情况下对象会进入临时状态：

1，执行save()或saveOrUpdate()方法，使临时对象转变为持久化对象。

2，执行upda()或saveOrUpdate()方法，使游离对象转变为持久化对象。

3，执行load()或get()方法，返回的对象都是持久化对象。

4，执行find()方法，返回List集合中存放的都是持久化对象。

5，在允许级联保存的情况下，Session在清理缓存时会把与持久化对象关联的临时对象转变为持久化对象。

例如：Session session = factory.openSession();  object.setName("持久化对象"); session.save(object);

此时object对象为持久化对象，Session缓存中有相关联的实例，数据库中有相应的记录。

游离状态：是指从持久化对象的Session对象被销毁到该对象消失之前的状态，此时对象不在Session的缓存中。

处在此状态的对象具备以下特点：

1，不在Session缓存中，不与任何Session实例相关联。

2，在数据库中有与之对应的记录（前提是没有其他Session实例删除该条记录）。

通常在下列情况下对象会进入临时状态：

1，执行close()方法，将Session缓存清空，缓存中的所有持久化对象将转变成游离对象。

2，执行evict()方法，能从缓存中删除一个持久化对象，使之转变成游离对象。

例如：session.close();

此时上文的object对象为游离对象，Session缓存中没有有相关联的实例，数据库中有相应的记录。

三种状态里面，只有持久化状态在Session缓存中有相关联的实例，临时状态跟游离状态都没有。临时状态数据库里没有对应的记录，其他两种可能又记录，也可能没有记录。

引用：http://www.cnblogs.com/liushuijinger/p/3543750.html

 hibernate工作流程
（1）启动Hibernate
（2）构建Configuration实例，初始化实例中的所有变量：
Configuration cfg = Configuration.configure();
（3）加载hibernate.cfg.xml文件至cfg实例所分配的内存
（4）通过hibernate.cfg.xml文件 中格的mapping节点进行配置，并加载.hbm.xml文件至cfg实例中
（5）由cfg实例构建一个SessionFactory实例：
SessionFactory sf = cfg.buildSessionFactory();
（6）由上面得到的sf实例创建Session连接：
Session s = sf.openSession();
（7）由Session实例创建事务操作接口Transaction的一个实例：
Transaction tx = s.beginTransaction();
（8）通过Session接口提供的各种方法操作对数据库的访问
（9）提交数据库操作结果：
tx.commit();
（10）关闭Session连接：
s.close(); 

hibernate与mybatis的区别 性能差异 为什么
hibernate是全自动，他会自动生成所有SQL，调优不太方便，它的主要思想是orm，对象关系映射
mybatis是半自动，它需要配置SQL和resultmap，调优方便，它的主要思想是sqlmapping
hibernate有更好的数据库移植性，而且二级缓存优于ibatis
不考虑缓存的情况 hibernate的性能高于ibatis

Struts2工作原理
  在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 框架中继承的标签。在这个过程中需要涉及到ActionMapper 
Struts2工作流程
  1、客户端浏览器发出HTTP请求.
  2、根据web.xml配置，该请求被FilterDispatcher接收
  3、根据struts.xml配置，找到需要调用的Action类和方法， 并通过IoC方式，将值注入给Aciton
  4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
  5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面
  6、返回HTTP响应到客户端浏览器 

 

spring Mvc和struts的区别 性能差异 为什么
mvc开发效率高，mvc配置方便于struts
struts是类级别拦截，一个类对应一个request上下文，mvc是方法级别拦截，一个方法对应一个request上下文，mvc更容易实现restful
mvc设计思路：将整个处理流程规范化，将每个不同的请求分发到不同的组件，设计清晰，直观

mvc性能更好，struts使用标签库，ognl，值栈等功能会降低struts的性能，而且，struts会把每个请求封装到map里以供action使用，保证线程安全.

 

解释AOP

 aop面向切面编程，是oop的重要补充，可以在不修改原有业务逻辑的前提下，加入一些公共的模块，比如日志，权限验证，事物管理。
可以通过编程式或注解式的方式实现。
aop主要通过jdk反射机制和cglib类和包实现，具体看目标类的类型，如果是接口，则使用jdk反射机制的方式。 

 

解释IOC

 ioc本身是一种设计思想，通过ioc容器可以很轻易的得到我们想要的对象或实例，它会自动注入值生成对象，这就是一种控制反转。
ioc最重要的一点就是在程序运行的时候可以动态的向某个对象提供所它依赖对象的实例。这就是通过依赖注入实现的。
依赖注入就是通过反射机制实现的，反射机制可以在程序运行的时候，得到一个对象所属的类，得到一个类的成员变量和方法，动态的创建类对象，动态的调用对象的方法。
具体实现就是参考XMLbeanfactory，classpathXMLapplicationcontext，applicationcontext除了提供基本的ioc功能外，还提供国际化，jndi，外部应用事件 

 

解释rmi
rmi包括客户端和服务端，他是通过tcp/ip加端口的方式访问，
客户端主要通过rmiproxyfactorybean对客户端进行封装，生成代理对象，查询得到Rmi的stub对象，并通过stub对象发起相应的远程调用请求。
服务端主要是通过rmiserviceexport导出远程调用对象的引用，同时将导出的对象同注册器绑定供客户端查询。 

 

 ioc aop优缺点
IOC是解耦,提供一种构造对象的方式，使得一种功能能有多种实现，且不构成依赖。spring 的IOC的缺点：占用内存多、构造对象慢、启动慢。
springAOP是提供一种基于spring框架的切面编程企业级解决方案，虽然这个已经很强大，但是依然还是没有aspectj强大，比如：目前还不支持流程切面。织入慢执行效率低、不支持new关键字创建的对象的切入，必须使用bean factory织入。 

 

spring事物应用

应用场景，如何使用

 

spring上下文

Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。 

 

 AOP原理

 Spring提供了两种方式来生成代理对象: JDKProxy和Cglib，具体使用哪种方式生成由AopProxyFactory根据AdvisedSupport对象的配置来决定。默认的策略是如果目标类是接口，则使用JDK动态代理技术，否则使用Cglib来生成代理。下面我们来研究一下Spring如何使用JDK来生成代理对象，具体的生成代码放在JdkDynamicAopProxy这个类中
配置可以通过xml文件来进行，大概有四种方式：
1.        配置ProxyFactoryBean，显式地设置advisors, advice, target等
2.        配置AutoProxyCreator，这种方式下，还是如以前一样使用定义的bean，但是从容器中获得的其实已经是代理对象
3.        通过<aop:config>来配置
4.        通过<aop: aspectj-autoproxy>来配置，使用AspectJ的注解来标识通知及切入点

下面的问题是，代理对象生成了，那切面是如何织入的？
我们知道InvocationHandler是JDK动态代理的核心，生成的代理对象的方法调用都会委托到InvocationHandler.invoke()方法。而通过JdkDynamicAopProxy的签名我们可以看到这个类其实也实现了InvocationHandler，下面我们就通过分析这个类中实现的invoke()方法来具体看下Spring AOP是如何织入切面的。
主流程可以简述为：获取可以应用到此方法上的通知链（Interceptor Chain）,如果有,则应用通知,并执行joinpoint; 如果没有,则直接反射执行joinpoint
这个方法执行完成后，Advised中配置能够应用到连接点或者目标类的Advisor全部被转化成了MethodInterceptor.
如果得到的拦截器链为空，则直接反射调用目标方法，否则创建
MethodInvocation，调用其proceed方法，触发拦截器链的执行