SSE java demo示例 javassh

转载

码海舵手之心 2024-07-25 10:01:45

文章标签 SSE java demo示例 Java面试题 AOP 目标对象 ORM 文章分类 Java 后端开发

1. Spring

1.1 Spring是什么
Spring是一个开源框架，Spring是一个轻量级的控制反转(IOC)和面向切面(AOP)的容器框架。让java开发模块化，并且全面。贯穿逻辑层，表现层，持久层。让每一个功能模块都可以独立分开，降低耦合，提高代码复用率。spring通过控制反转降低耦合性，一个对象的依赖通过被动注入的方式而非主动new，还包括面向切面，mvc的整合等等，spring正如其字面意思，是程序员的春天，大大地降低了体力劳动。
Spring 主要的功能是对象依赖关系的注入，以及方法执行前、后的监视（切片）。在实现途径上，通过 Spring 执行的每一个方法，都不是直接执行，而是通过代理程序的方式。
1.2 Spring优点
更优雅的组织和管理java类
使J2EE易用和促进良好的编码习惯
Spring是开源的免费的，使得对象管理集中化和简单化，依赖注入和IOC使得JDBC操作简单化
1、轻量级的容器框架没有侵入性；
2、使用IoC容器更加容易组合对象之间的直接关系，面向接口编程，降低耦合；
3、使用AOP可以更加容易的进行功能扩展；
4、创建对象默认是单例的，不需要再使用单例模式进行处理。
1.3 JDBC数据源
Spring提供了两种JDBC数据源对象：
DriverManagerDataSource ：在每个连接请求时都会返回一个新建的连接。没有进数据池化管理。
SingleConnectionDataSource：在每个连接请求时都会返回同一个连接。
1.4 Spring为ORM框架提供的一些服务
Spring声明式事物的集成支持。
透明的异常处理
线程安全的、轻量级的模板类。
DAO支持类。
资源管理。
1.5 什么是AOP，好处，用在什么方面
面向切面编程
针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，以获得逻辑过程中各部分之间低耦合性的隔离效果。
无关业务流程加入到固化业务流程，不相关的业务组合到一起，逻辑单一清晰。
事务，安全，日志，缓存。
1.6 AOP原理
AOP面向切面编程，是对OOP面向对象编程的一种补充和完善。AOP 实际上是由目标类的代理类实现的。AOP 代理其实是由 AOP 框架动态生成的一个对象，该对象可作为目标对象使用。AOP 代理包含了目标对象的全部方法，但 AOP 代理中的方法与目标对象的方法存在差异，AOP 方法在特定切入点添加了增强处理，并回调了目标对象的方法。
1.7 IOC
IOC是一种叫做“控制反转”的设计思想。控制权的转移就是所谓的反转控制权交给容器，不需要关系组件装配细节。
1.8 IOC原理
工厂模式加反射机制。
1.9 DI，方式
DI：依赖注入，在运行期，由外部容器动态地将依赖对象注入到组件中。
方式：基于构造函数的依赖注入，基于setter方法注入，接口注入
1.10 为了降低Java开发的复杂性，Spring采取了以下4 种关键策略
基于POJO的轻量级和最小侵入性编程
通过依赖注入和面向接口实现松耦合
基于切面和惯例进行声明式编程
通过切面和模板减少样板式代码
1.11 Spring减少XML的配置数量
自动装配（autowiring）有助于减少甚至消除<property>元素和<constructor-arg>元素，让Spring自动识别如何装配Bean的依赖关系。
自动检测（autudiscovery）比自动装配更进一步，让Spring能够自动识哪些类需要被配置成Spring Bean，从而减少对Bean元素的使用。
1.12 几种类型的自动装配
byName——把与Bean的属性具有相同名字（或者ID）的其它Bean自动装配到对应属性中。如果没有跟属性的名字相匹配的Bean，则该属性不进行装配。
byType——把与Bean的属性具有相同类型的其它Bean自动装配到对应属性中。如果没有跟属性的类型相匹配的Bean，则该属性不进行装配。
constructor——把与Bean构造器参数具有相同类型的其他Bean自动装配到Bean构造器的对应参数中。
autodetect——首先尝试使用constructor进行自动装配，如果失败，再尝试使用byType进行自动装配。
1.13 切面,切点
切面(Aspect): 指交叉业务逻辑的统称, 比如日志,事务,安全，缓存（切入切点的规则）
切点(Pointcut):指通知(切面的具体实现)应用到哪些目标对象的哪些方法决定了通知在何处执行(可以插入的点)
1.14 Spring事务的支持
编码式事务管理
声明式事务管理
1.15 Spring中的jdbc与传统的jdbc有什么区别
Spring的JDBC是在原生态JDBC上面的一层简单的封装，提供了一些一用的接口，节省代码，不管连接，不管事务、不管异常、不管关闭。只需要实现Spring提供的回调类。
Spring JDBC只需要实现创建语句和返回结果集两个步骤，其他的都由Spring完成。
1.16 Spring提供了在Spring上下中配置数据源Bean的多种方式
通过JDBC驱动程序定义数据源。
通过JNDI（Java命名系统接口）查找数据源。
连接池的数据源。
1.17 Spring中Bean生命周期
一个对象的生命周期：创建（实例化-初始化）——使用——销毁，在Spring中，Bean对象周期当然遵从这一过程，但是Spring提供了许多对外接口，允许开发者对三个过程（实例化、初始化、销毁）的前后做一些操作。
1. Spring容器从XML 文件中读取bean的定义，并实例化bean。
2. Spring根据bean的定义填充所有的属性。
3. 如果bean实现了BeanNameAware 接口，Spring 传递bean 的ID 到 setBeanName方法。
4.如果Bean 实现了 BeanFactoryAware 接口， Spring传递beanfactory 给setBeanFactory 方法。
5.如果有任何与bean相关联的BeanPostProcessors，Spring会在postProcesserBeforeInitialization()方法内调用它们。
6. 如果bean实现IntializingBean了，调用它的afterPropertySet方法，如果bean声明了初始化方法，调用此初始化方法。
7. 如果有BeanPostProcessors 和bean 关联，这些bean的postProcessAfterInitialization() 方法将被调用。
8. 如果bean实现了 DisposableBean，它将调用destroy()方法。
1.18 Spring提供的4种各具特色的AOP支持
基于代理的经典AOP。
@AspectJ注解驱动切面。
纯POJO切面。
注入式AspectJ切面
1.19 织入的时机
编译期——切面在目标类编译时被织入。
类加载期——切面在目标类加载到JVM时被织入，这种方式需要特殊的类加载器，可以在目标类被引入应用之前增强该目标类的字节码。
运行期——切面在应用运行的某个时刻被织入，一般情况下，在织入切面时，AOP容器会为目标对象动态地创建一个代表对象。
1.20 Spring切面可以应用5种类型的通知
Before——在方法调用之前调用通知。
After——在方法完成之后调用通知，无论方法执行是否成功。
After-returning—— 在生方法成功执行之后调用通知。
After-throwing——在方法抛出异常后调用通知。
Around——通知包裹了被通知的方法，在被通知的方法调用之前和调用之后执行自定义的行为。
1.21 代理对象(proxy object)
为目标对象增加新功能从而产生的一个新的对象称为代理对象，负责调用拦截器和目标对象的方法。
1.22 目标对象(target object)
需要被增强功能的对象称之为目标对象,也被称为被增强或被代理对象。
1.23 织入(Weaving)
将切面应用到目标对象来创建新的代理对象的过程。
1.24 连接点(joinpoint)，切入点(pointcut)
程序运行过程中的某一点，比如方法调用、属性访问、异常抛出。
一组连接点，如果要有选择性地拦截目标对象中的方法的话需要定义切入点。
1.25 增强(advice)或者通知
在不修改原有代码的前提下,为某一个对象增加新的功能，在spring中增强是通过拦截器实现的。
1.26 spring自动检测Bean
为了配置自动检测，需要使用<context:component-scan>元素。默认情况下，<context:component-scan>使用构造型注所标注类。这些特殊的注解如下：
@Component——通用构造型注解，标识该类为Spring组件
@Controller——标识将该类定义为SpringMVC controller
@Respository——标识将该类定义为数据仓库
@Service——标识将该类定义为服务
1.27 使用Spring注解装配
<context:annotation-config>元素告诉Spring使用基于注解的自动装配。
1.28 Spring应用上下文的有哪些
① AnnotationConfigApplicationContext:从一个或多个基于java的配置类中加载上下文定义，适用于java注解的方式；
② ClassPathXmlApplicationContext:从类路径下的一个或多个xml配置文件中加载上下文定义，适用于xml配置的方式；
③ FileSystemXmlApplicationContext:从文件系统下的一个或多个xml配置文件中加载上下文定义，也就是说系统盘符中加载xml配置文件；
④ AnnotationConfigWebApplicationContext:专门为web应用准备的，适用于注解方式；
⑤ XmlWebApplicationContext:从web应用下的一个或多个xml配置文件加载上下文定义，适用于xml配置方式。
1.29 Spring 为什么默认把bean设计成单例的，单例bean与原型bean的区别
为了提高性能：
1.少创建实例
2.垃圾回收
3.缓存快速获取
单例bean与原型bean的区别：
如果一个bean被声明为单例的时候，在处理多次请求的时候在spring 容器里只实例化出一个bean，后续的请求都公用这个对象，这个对象会保存在一个map里面。当有请求来的时候会先从缓存(map)里查看有没有，有的话直接使用这个对象，没有的话才实例化一个新的对象，所以这是个单例的。但是对于原型(prototype)bean来说当每次请求来的时候直接实例化新的bean，没有缓存以及从缓存查的过程。
概括说：单例的bean只有第一次创建新的bean 后面都会复用该bean，所以不会频繁创建对象，原型的bean每次都会新创建，由于不会每次都新创建新对象所以单例bean有一下几个性能上的优势：
1.减少了新生成实例的消耗
新生成实例消耗包括两方面，第一，spring会通过反射或者cglib来生成bean实例这都是耗性能的操作，其次给对象分配内存也会涉及复杂算法
2.减少jvm垃圾回收
由于不会给每个请求都新生成bean实例，所以自然回收的对象少了
3.可以快速获取到bean
因为单例的获取bean操作除了第一次生成之外其余的都是从缓存里获取的所以很快
单例的bean一个很大的劣势是不能做到线程安全。
1.30 给一个 Bean 的 message 属性, 字符串类型, 注入值为 "Hello" 的 XML 配置文件该怎么写?
<bean id="" class="">
<property name="message" value="hello"/>
</bean>
1.31. spring 核心模块
Spring有七大功能模块，分别是Spring Core，AOP，ORM，DAO，MVC，WEB，Context。
1，Spring Core
Core模块是Spring的核心类库，Spring的所有功能都依赖于该类库，Core主要实现IOC功能，Sprign的所有功能都是借助IOC实现的。
2，AOP
AOP模块是Spring的AOP库，提供了AOP（拦截器）机制，并提供常用的拦截器，供用户自定义和配置。
3，ORM
Spring 的ORM模块提供对常用的ORM框架的管理和辅助支持，Spring支持常用的Hibernate，ibtas，jdao等框架的支持，Spring本身并不对ORM进行实现，仅对常见的ORM框架进行封装，并对其进行管理
4，DAO模块
Spring 提供对JDBC的支持，对JDBC进行封装，允许JDBC使用Spring资源，并能统一管理JDBC事物，并不对JDBC进行实现。（执行sql语句）
5，WEB模块
WEB模块提供对常见框架如Struts1，WEBWORK（Struts 2），JSF的支持，Spring能够管理这些框架，将Spring的资源注入给框架，也能在这些框架的前后插入拦截器。
6，Context模块
Context模块提供框架式的Bean访问方式，其他程序可以通过Context访问Spring的Bean资源，相当于资源注入。
7，MVC模块
WEB MVC模块为Spring提供了一套轻量级的MVC实现，在Spring的开发中，我们既可以用Struts也可以用Spring自己的MVC框架，相对于Struts，Spring自己的MVC框架更加简洁和方便。
1.32. 在Spring中如何注入一个java集合？
Spring提供以下几种集合的配置元素：
<list>类型用于注入一列值，允许有相同的值。
<set> 类型用于注入一组值，不允许有相同的值。
<map> 类型用于注入一组键值对，键和值都可以为任意类型。
<props>类型用于注入一组键值对，键和值都只能为String类型。
1.33. Spring框架中都用到了哪些设计模式？
代理模式：在AOP和remoting中被用的比较多。
单例模式：在spring配置文件中定义的bean默认为单例模式。
模板方法模式：用来解决代码重复的问题。
前端控制器模式：Spring提供了DispatcherServlet来对请求进行分发。
依赖注入模式：贯穿于BeanFactory / ApplicationContext接口的核心理念。
工厂模式：BeanFactory用来创建对象的实例。
1.34. BeanFactory 和ApplicationContext的区别
BeanFactory和ApplicationContext都是接口，并且ApplicationContext是BeanFactory的子接口。
BeanFactory是Spring中最底层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能。而 ApplicationContext是Spring的一个更高级的容器，提供了更多的有用的功能。
ApplicationContext提供的额外的功能：国际化的功能、消息发送、响应机制、统一加载资源的功能、强大的事件机制、对Web应用的支持等等。
加载方式的区别：BeanFactory采用的是延迟加载的形式来注入Bean；ApplicationContext则相反的，它是在Ioc启动时就一次性创建所有的Bean,好处是可以马上发现Spring配置文件中的错误，坏处是造成浪费。

2. Springmvc

2.1 MVC的各部分有那些技术来实现
Model 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），View 是应用的表示面（由JSP页面产生），Controller 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。好处是可以将界面和业务逻辑分离。
2.2 *Spring mvc工作原理
1.DispatcherServlet前端控制器接收发过来的请求，交给HandlerMapping处理器映射器
2.HandlerMapping处理器映射器，根据请求路径找到相应的HandlerAdapter处理器适配器（处理器适配器就是那些拦截器或Controller）
3.HandlerAdapter处理器适配器，处理一些功能请求，返回一个ModelAndView对象（包括模型数据、逻辑视图名）
4.ViewResolver视图解析器，先根据ModelAndView中设置的View解析具体视图
5.然后再将Model模型中的数据渲染到View上
这些过程都是以DispatcherServlet为中轴线进行的。

3. Mybatis

3.1. # 和 $
#将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号
#方式能够很大程度防止sql注入
$将传入的数据直接显示生成在sql中
使用$占位符可能会导致S，能用#的地方就不要使用$，写order by子句的时候应该用$而不是#。
3.2. 常用orm框架
ORM就是对象关系匹配，是为了解决面向对象与关系数据库存在的互不匹配的问题。简单来说，就是把关系数据库中的数据转换成面向对象程序中的对象。
常用的ORM框架有Hibernate和MyBatis，也就是ssh组合和ssm组合中的h与m。
Hibernate对数据库结构提供了完整的封装，实现了POJO对象与数据库表之间的映射，能够自动生成并执行SQL语句。只要定义了POJO 到数据库表的映射关系，就可以通过Hibernate提供的方法完成数据库操作。Hibernate符合JPA规范，就是Java持久层API。
MyBatis通过映射配置文件，将SQL所需的参数和返回的结果字段映射到指定对象，MyBatis不会自动生成SQL，需要自己定义SQL语句，不过更方便对SQL语句进行优化。
总结起来：
Hibernate配置要比mybatis复杂的多，学习成本也比MyBatis高。MyBatis，简单、高效、灵活，但是需要自己维护SQL；
Hibernate功能强大、全自动、适配不同数据库，但是非常复杂，灵活性稍差。
3.3. mybatis 有几种分页方式
数组分页：查出所有数据，在list中截取需要的部分。
Sql分页：limit关键字
拦截器分页
RowBounds实现分页
3.4. mybatis 有哪些执行器
SimpleExecutor：每执行一次update或select，就开启一个Statement对象，用完立刻关闭Statement对象。
ReuseExecutor：执行update或select，以sql作为key查找Statement对象，存在就使用，不存在就创建，用完后，不关闭 Statement对象，而是放置于Map内，供下一次使用。简言之，就是重复使用Statement对象。
BatchExecutor：执行update（没有select，JDBC批处理不支持select），将所有sql都添加到批处理中（addBatch()），等待统一执行（executeBatch()），它缓存了多个Statement对象，每个Statement对象都是addBatch()完毕后，等待逐一执行executeBatch()批处理。与JDBC批处理相同。
3.5. mybatis工作原理
1.读取核心配置文件并返回InputStream流对象。
2.根据InputStream流对象解析出Configuration对象，然后创建SqlSessionFactory工厂对象
3.根据一系列属性从SqlSessionFactory工厂中创建SqlSession
4.从SqlSession中调用Executor执行数据库操作&&生成具体SQL指令
5.对执行结果进行二次封装
6.提交与事务
3.6. 解释一下MyBatis中命名空间（namespace）的作用。
在大型项目中，可能存在大量的SQL语句，这时候为每个SQL语句起一个唯一的标识（ID）就变得并不容易了。为了解决这个问题，在MyBatis中，可以为每个映射文件起一个唯一的命名空间，这样定义在这个映射文件中的每个SQL语句就成了定义在这个命名空间中的一个ID。只要我们能够保证每个命名空间中这个ID是唯一的，即使在不同映射文件中的语句ID相同，也不会再产生冲突了。
3.7. JDBC编程有哪些不足之处，MyBatis是如何解决这些问题的？
1、JDBC：数据库链接创建、释放频繁造成系统资源浪费从而影响系统性能，如果使用数据库链接池可解决此问题。
MyBatis：在SqlMapConfig.xml中配置数据链接池，使用连接池管理数据库链接。
2、JDBC：Sql语句写在代码中造成代码不易维护，实际应用sql变化的可能较大，sql变动需要改变java代码。
MyBatis：将Sql语句配置在XXXXmapper.xml文件中与java代码分离。
3、JDBC：向sql语句传参数麻烦，因为sql语句的where条件不一定，可能多也可能少，占位符需要和参数一一对应。
MyBatis： Mybatis自动将java对象映射至sql语句。
4、DBC：对结果集解析麻烦，sql变化导致解析代码变化，且解析前需要遍历，如果能将数据库记录封装成pojo对象解析比较方便。
MyBatis：Mybatis自动将sql执行结果映射至java对象。
3.8. 简单的说一下MyBatis的一级缓存和二级缓存？
Mybatis首先去缓存中查询结果集，如果没有则查询数据库，如果有则从缓存取出返回结果集就不走数据库。Mybatis内部存储缓存使用一个HashMap，key为hashCode+sqlId+Sql语句。value为从查询出来映射生成的java对象。
Mybatis的二级缓存即查询缓存，它的作用域是一个mapper的namespace，即在同一个namespace中查询sql可以从缓存中获取数据。二级缓存是可以跨SqlSession的。
3.9. mybatis如何处理结果集
MyBatis的结果集是通过反射来实现的。并不是通过get/set方法。在实体类中无论是否定义get/set()方法，都是可以接收到的。

4. Hibernate

4.1 什么是Hibernate
Hibernate是对象-关系转换工具，并且能够在软件层面实现分布式事务。
Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合。使用Hibernate 框架，不用写JDBC 代码，仅仅是调用一个save 方法，就可以将对象保存到关系数据库中，仅仅是调用一个get 方法，就可以从数据库中加载出一个对象。
Hibernate的核心接口一共有5个，分别为:Session、SessionFactory、Transaction、Query和Configuration。这5个核心接口在任何开发中都会用到。通过这些接口，不仅可以对持久化对象进行存取，还能够进行事务控制。
使用Hibernate 的基本流程是：配置Configuration 对象、产生SessionFactory、创建 session对象，启动事务，完成CRUD 操作，提交事务，关闭session。使用Hibernate 时，先要配置hibernate.cfg.xml 文件，还要为每个实体配置相应的hbm.xml 文件，hibernate.cfg.xml 文件中需要登记每个hbm.xml文件。
4.2 Hibernate中对象三种状态
临时状态：刚刚使用new语句创建，还没有被持久化，不处于Session的缓存中。处于临时状态的状态的Java对象被称为临时对象。
持久化状态：已经被持久化，加入到Session的缓存中。处于持久化状态的Java对象被称为持久化对象。
游离状态：已经被持久化，但不处于session的缓存中。处于游离状态的Java对象被称为游离对象。
4.3 hibernate中的update()和saveOrUpdate()的区别，session的load()和get()的区别
update是更新一个对象，针对的是已经存在的对象
saveOrupdate是根据实体判断，如果没有的话就保存实体，如果有实体的话才修改
load()和get()最主要的区别就在于是否进行延迟加载，load不会立即访问数据库，当试图加载的数据不存在的时候，load方法返回未初始化的代理对象，而get方法会直接访问数据库，当试图加载的数据不存在的时候，直接返回null。
4.4 简述 Hibernate 和 JDBC的优缺点
Hibernate就是封装了JDBC，它可以写一条hql语句，可以再不同数据库中使用，不用修改hql语句，但是关联查询效率低，而JDBC则需要根据不同的数据库些不同的sql语句。
开发效率上讲，持久层关系映射很复杂的情况下，Hibernate开发效率非常高。
内存消耗上讲，JDBC省内存。
运行效率上讲，如果JDBC的代码写的非常优化，那么JDBC架构运行效率最高，但是实际项目中几乎做不到，因此Hibernate架构表现更快的运行效率。
4.5 hibernate和mybatis的区别
MyBatis可以进行更为细致的SQL优化，可以减少查询字段。
MyBatis容易掌握，而Hibernate门槛较高。
Hibernate对对象的维护和缓存要比MyBatis好，对增删改查的对象的维护要方便。
Hibernate数据库移植性很好，MyBatis的数据库移植性不好，不同的数据库需要写不同SQL。
Hibernate有更好的二级缓存机制，可以使用第三方缓存。MyBatis本身提供的缓存机制不佳。
4.6 hibernate的inverse属性的作用
Hibernate仅仅按照主控方对象的状态的变化来同步更新数据库属性inverse，它是用来指定关联的控制的。inverse属性默认是false，若为false，则关联由自己控制，若为true，则关联由对方控制。
4.7 Hibernate的二级缓存
二级缓存SessionFactory是全局性的，所有的session都共享这个二级缓存。
很少被修改的数据，不是很重要的数据适合存放到第二级缓存中。
4.8. Hibernate的一对多和多对一双向关联的区别？
一对多关联映射和多对一关联映射实现的基本原理都是一样的，既是在多的一端加入一个外键指向一的一端外键，而主要的区别就是维护端不同。
它们的区别在于维护的关系不同：
一对多关联映射是指在加载一的一端数据的同时加载多的一端的数据多对一关联映射是指在加载多的一端数据的同时加载一的一端的数据。
4.9. Hibernate是如何延迟加载?
Hibernate3 提供了属性的延迟加载功能。当Hibernate在查询数据的时候，数据并没有存在于内存之中，而是当程序真正对数据的操作时，对象才存在于内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
4.10. Hibernate中怎样实现类之间的关系?
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们在程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many进行操作。
4.11. 如何优化Hibernate？
1.使用双向一对多关联，不使用单向一对多
2.灵活使用单向一对多关联
3.不用一对一，用多对一取代
4.配置对象缓存，不使用集合缓存
5.一对多集合使用Bag,多对多集合使用Set
6. 继承类使用显式多态
7. 表字段要少

5. Struts

5.1.   Struts的优缺点
优点：
实现了MVC模式，层次结构清晰，使程序员只需关注业务逻辑的实现。
丰富的标签库，大大提高了开发的效率，提供丰富的拦截器实现。
通过配置文件，就可以掌握整个系统各个部分之间的关系。
异常处理机制，只需在配置文件中配置异常的映射，即可对异常做相应的处理。
可扩展性高，面向切面编程的思想在Strut中也有了很好的体现。
缺点： Struts2中Action中取得从jsp中传过来的参数时有点麻烦，校验繁琐，安全性有待提高。
5.2.   Struts和springmvc的区别
spring mvc的入口是servlet，而struts2是filter，这样就导致了二者的机制不同。
spring mvc是基于方法的设计，而sturts是基于类。
struts更加符合oop(面向对象编程)的编程思想， spring就比较谨慎，在servlet上扩展。
struts有自己的interceptor机制，spring mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring mvc大。
spring mvc使用更加简洁，开发效率Spring MVC确实比struts2高。
5.3.   谈谈你对Struts2的理解
Struts2 是基于 Filter 进行跳转控制的工具，封装了从不同请求路径到不同程序的分发过程。
5.4.   简要阐述struts2的工作流程
1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被FilterDispatcher接收。
3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。
5.5.   说下Struts的设计模式
MVC模式
1，web应用程序启动时就会加载并初始化ActionServlet；
2，用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据；
3，ActionServlet根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate()验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法；
4，Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件；
5，ActionForward对象指定的jsp生成动态的网页，返回给客户。

6. log

6.1. 使用Log4j对程序有影响吗
有，log4j是用来日志记录的，记录一些关键敏感的信息，通常会将日志记录到本地文件或者数据库中。记录在本地文件中，会有频繁的io操作，会耗费一些系统资源。记录在数据库中，会频繁地操作数据库表，对系统性能也有一定的影响。但是为了程序安全以及数据的恢复或者bug的跟踪，这点资源消耗是可以承受的。
6.2. Log4j日志有几个级别
由低到高：debug、info、wran、error

7. SpringData Jpa

7.1. JPA
JPA是Sun官方提出的Java持久化规范，提供了一些编程的API接口，主要是为了简化现有的持久化开发工作和整合ORM技术，具有易于使用，伸缩性强等优点。JPA不是ORM框架，JPA并未提供ORM实现，具体实现则由服务厂商来提供实现。JPA是一套规范，不是一套产品，像Hibernate、TopLink、JDO是一套产品，如果说这些产品实现了这个JPA规范，那么就可以称他们为JPA的实现产品。
7.2. Spring Data JPA
Spring Data JPA 是 SpringData中的一个子模块，是基于 ORM 框架、JPA 规范的基础上封装的一套JPA应用框架，使开发者用极简的代码即可实现对数据的访问和操作。Spring Data JPA 是在JPA规范的基础下提供了Repository层的实现，解脱了DAO层的操作。Spring Data JPA 底层默认实现是使用Hibernate。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。