设计模式

1. 什么是设计模式？你是否在你的代码里面使用过任何设计模式？

设计模式是在软件设计中常见问题的通用、可反复使用、多数人知晓的一种解决方案或模板；这些解决方案是在相当长的一段时间内由众多软件开发人员通过反复试验获得的。

设计模式可分为创建型模式、结构型模式以及行为型模式

创建型模式：单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式

行为型模式：模板方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式

1. 你可以说出几个在JDK库中使用的设计模式吗？

Decorator（装饰在模式）设计模式常被用于Java IO流中

Singleton（单例模式）常被用在运行环境中，Calendar以及各种其他类

Factory（工厂模式）常被用于各种不可变类

Obsever(观察者模式)常被用于Swing和许多事件监听器框架中。

1. Java中什么是单例设计模式？用Java写出线程安全的单例

单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

懒汉式

public class SingletonDemo2 {
private static SingletonDemo2 instance;
private SingletonDemo2() {
}
public static synchronized SingletonDemo2 getInstance() {
if (instance == null) {
instance = new SingletonDemo2();
}
return instance;
}
}

饿汉式

public class SingletonDemo1 {
private static SingletonDemo1 instance = new SingletonDemo1();
private SingletonDemo1() {
}
public static SingletonDemo1 getInstance() {
return instance;
}
}

枚举式

public enum SingletonDemo5 {
INSTANCE;
private SingletonDemo5() {
}
public void singletonOperation() {
}
}

静态内部类式

public class SingletonDemo4 {
private SingletonDemo4() {
}
public static SingletonDemo4 getInstance() {
return SingletonDemo4.SingletonClassInstance.instance;
}
private static class SingletonClassInstance {
private static final SingletonDemo4 instance = new SingletonDemo4((SingletonDemo4)null);
private SingletonClassInstance() {
}
}
}

1. 使用工厂模式最主要的好处是什么？你在哪里使用？

在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。解决了接口选择的问题，实现了创建者和调用者的分离。

使用场景：

(1)数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。

(2)设计一个连接服务器的框架，需要三个协议，"POP3"、"IMAP"、"HTTP"，可以把这三个作为产品类，共同实现一个接口。

1. 在Java中，什么叫观察者设计模式（observer design pattern）？

Observer(观察者模式)：定义对象间的一种一对多的依赖关系,以便当一个对象的状态发生改变时,所有依赖于它的对象都得到通知并自动刷新

1. 举一个用Java实现的装饰模式(decorator design pattern)？它是作用于对象层次还是类层次？

装饰模式就是在不必改变原类文件和使用继承的情况下给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。它是通过场景一个包装对象，也就是装饰来包裹真实的对象。

装饰模式角色组成：

（1）抽象构件（Component）角色：给出一个抽象接口，以规范准备接收附加职责的对象。

（2）具体构件（Concrete Component）角色：定义一个将要接收附加职责的类。

（3）装饰（Decorator）角色：持有一个构件（Component）对象的实例，并实现一个与抽象构件接口一致的接口，从外类来扩展Component类的功能，但对于Component类来说，是无需知道Decorato的存在的。

（4）具体装饰（Concrete Decorator）角色：负责给构件对象添加上附加的职责。

装饰模式作用于类层次。

1. 什么是MVC设计模式？举一个MVC设计模式的例子？

MVC:Model-View-Controller(模型-视图-控制器)

Model（模型）-模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。

View（视图）-视图代表模型包含的数据的可视化。

Controller（控制器）-控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。

MVC设计模式实例：

创建一个作为模型的 Student 对象。StudentView 是一个把学生详细信息输出到控制台的视图类，StudentController 是负责存储数据到 Student 对象中的控制器类，并相应地更新视图 StudentView。

1. Java中什么是表示层设计模式（FrontController design pattern）？举一个使用表示层设计模式（front controller pattern）的例子？

MVC将用户接口问题分割为三个截然不同的部分：模型、视图和控制器。模型存储应用的状态。视图解释模型中的数据并将它展示给用户。最后控制器处理用户的输入。

因为表示层是请求驱动的，所以“用户”可以是任意请求的发起者。控制器处理该请求。模型就是业务数据，而视图就是最终发生的应答。控制器是与请求发生联系的起点。控制器就是一个主管，首先规划要做哪些更新和要显示什么视图，然后调用被选择的模式和视图以执行真正的规划。模型的工作是管理对该状态的访问，为控制器和视图提供统一的接口。视图从模型中读取数据，并使用这些数据来生成应答。

控制器不仅是接触请求的起点，它还是我们编程量最多和设计自由度最大的地方。前端控制器（Front Controller）模式主张构建一个单独的控制器执行每个请求中都需要的公共功能，而将其他的功能委托给与页面相关的控制器。前端控制器（Front Controller）提供了一个统一的位置来封装公共请求处理。前端控制器模式中的主要参与者是控制器本身。它的工作相当简单：执行公共的任务，然后把控制转移给与页面相关的控制器。

页面控制器执行模型更新和视图选择，实际上有些类似MVC模式中的控制器角色。页面控制器可以是完全独立的servlet，但是它们通常都按照GOF提出的命令（Command）模式实现为许多个更简单的类。在这种设计中，许多不同种类的页面控制器共享一个简单的公共接口，而且通常被称作“动作”（源于Command模式）。因为前端控制器选择了页面控制器，所以页面控制器最终负责选择正确的动作和视图。在一个Web应用中，前端控制器几乎总是用一个Servlet来实现。虽然使用JSP页面在技术上也是可行的，但这通常是一个坏主意——JSP页面不应该用于实现复杂的逻辑。第二种更引人注目的选择是使用一个servlet过滤器作为前端控制器。

1. 什么是责任链模式（Chain of Responsibility）？

Chain of Responsibility(责任链模式):为解除请求的发送者和接收者之间耦合，而使多个对象都有机会处理这个请求。将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它。

1. 什么是适配器模式？举用Java实现适配器模式的例子？

Adapter(适配器模式):

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

Java实现适配器模式：

2、JAVA JDK 1.1 提供了 Enumeration 接口，而在 1.2 中提供了 Iterator 接口，想要使用 1.2 的 JDK，则要将以前系统的 Enumeration 接口转化为 Iterator 接口，这时就需要适配器模式。

3、在 LINUX 上运行 WINDOWS 程序。

4、JAVA 中的 jdbc。

源码分析

1. Servlet有哪些常见类和接口,他们的作用是什么?

1.Servlet接口：

（1）init：负责初始化 Servlet 对象。容器一旦创建好 Servlet 对象后，就调用此方法来初始化 Servlet 对象

（2）service：负责处理客户的请求并返回响应。当容器接收到客户端要求访问特定的 servlet 请 求时，就会调用 Servlet 的 service 方法

（3）destroy：负责释放 Servlet 对象占用的资源，当 servlet 对象结束生命周期时， servlet 容器调用此方法来销毁 servlet 对象.

（4）getServletInfo：返回一个字符串，在该字符串中包含 servlet 的创建者，版本和版权等信息

（5）getServletConfig：返回一个 ServletConfig 对象，该对象中包含了 Servlet 初始化参数信息

2.ServletConfig接口：

(1)getServletName：用于获取servlet名，web.xml中定义的servlet-name

(2)getServletContext：获取servlet上下文对象

(3)getInitParameter：获取inin-param中的配置参数

(4)getInitParameterNames：获取配置的所有init-param名字集合

3.GenericServlet： Servlet类的默认实现类，与具体协议无关。在实现Servlet类的同时，也实现了ServletConfig接口和Serialzable接口。在GenericServlet类中唯一没有实现的方法是Servlet类中service方法，是交由子类去实现具体的应用。

4.HttpServlet:HttpServlet是基于Http协议实现的Servlet基类，在写servlet时直接继承它。在请求响应方法service中，根据请求类型调用不同的方法，写servlet只需要根据请求类型覆盖响应的方法即可

1. Tomcat有哪些常见类和接口,他们的作用是什么?

1.Server:服务器的意思，代表整个 tomcat 服务器，一个 tomcat 只有一个 Server. Server 中包含至少一个 Service 组件，用于提供具体服务。这个在配置文件中也得到很 好的体现（port=“8005” shutdown="SHUTDOWN"是在 8005 端口监听到"SHUTDOWN"命 令，服务器就会停止）

2.Servic:逻辑功能层， 一个 Server 可以包含多个 Service.Service 接收客户端的请求，然后解析请求，完成相应的业务逻辑，然后把处理后的结 果返回给客户端，一般会提供两个方法，一个 start 打开服务 Socket 连接，监听服务端口， 一个 stop 停止服务释放网络资源。

3.Connector:连接器，是 Service 的核心组件之一，一个 Service 可以有多个 Connector，主要是 连接客户端请求,用于接受请求并将请求封装成 Request 和 Response，然后交给 Container 进 行处理，Container 处理完之后在交给 Connector 返回给客户端。

4.Container:Service 的另一个核心组件，按照层级有 Engine，Host，Context，Wrapper 四种，一个 Service 只有一个 Engine，其主要作用是执行业务逻辑

5.Engine:一个 Service 中有多个 Connector 和一个 Engine，Engine 表示整个 Servlet 引擎，一个 Engine 下面可以包含一个或者多个 Host，即一个 Tomcat 实例可以配置多个虚拟主机，默认 的情况下 conf/server.xml 配置文件中<Engine name="Catalina" defaultHost="localhost"> 定 义了一个名为 Catalina 的 Engine。一个 Engine 包含多个 Host 的设计，使得一个服务器实例可以承担多个域名的服务

6.Host:代表一个站点，也可以叫虚拟主机，一个 Host 可以配置多个 Context，在 server.xml 文 件 中 的 默 认 配 置 为 <Host name="localhost" appBase="webapps" unpackWARs="true" autoDeploy="true">, 其中 appBase=webapps， 也就是<CATALINA_HOME>webapps 目录， unpackingWARS=true 属性指定在 appBase 指定的目录中的 war 包都自动的解压， autoDeploy=true 属性指定对加入到 appBase 目录的 war 包进行自动的部署。

7.Context: 代表一个应用程序，就是日常开发中的 web 程序，或者一个 WEB-INF 目录以 及下面的 web.xml 文件，换句话说每一个运行的 webapp 最终都是以 Context 的形式存在， 每个 Context 都有一个根路径和请求路径；与 Host 的区别是 Context 代表一个应用，如，默 认配置下 webapps 下的每个目录都是一个应用，其中 ROOT 目录中存放主应用，其他目录 存放别的子应用，而整个 webapps 是一个站点。

1. Mybatis的执行过程是什么?有哪些常用类和接口,他们的作用是什么?

执行过程：

Mybatis运行开始时，先通过Resources加载全局配置文件，加载完配置文件之后实例化SqlSessionFactory构建器，帮助SqlSessionFactory接口实现类DefaultSqlsessionFactory,在实例化DefaultSqlSessionFactory之前先创建XmlConfigBuilder解析器进行解析配置文件，然后利用解析器创建Configraction对象，并将解析结果放到Configraction中，然后将Configraction传递给DefaultSqlSessionFactory，此时SqlSessionFactory工厂创建完成。

然后再由SqlsessionFactory创建SqlSession，每次创建SqlSession时，都需要通过TransactionFactory创建Transaction对象，同时还需要创建SqlSession的执行器Executor,,最后实例化DefautSqlSession传递给SqlSession接口。然后根据项目需求使用SqlSession接口的API完成具体的事务操作。如果执行失败，则使用Rollback回滚事务，如果执行成功则调用commit提交事务，关闭SqlSession资源。

常用类和接口：

1.Resources：用于加载资源文件

2.SqlSessionFactoryBuilder:SqlSessionFactory的构建者类，首先调用 XMLConfigBuilder 类的构造器来创建一个 XML 配置构建器对象， 利用这个构建器对象来调用其解析方法 parse()来完成 Configuration 对象的创建，之后以这个配置对象为参数调用会话工厂构建者类中的 build(Configuration config)方法来完成SqlSessionFactory（会话工厂）对象的构建。

3.XmlConfigBuilder:Xml配置构建者类，是用来通过 XML 配置文件来构建 Configuration 对象实例， 构建的过程就是解析 Configuration.xml 配置文件的过程，期间会将从配置文件中获取到的指 定标签的值逐个添加到之前创建好的默认 Configuration 对象实例中。

4.Configraction:Mybaits上下文对象，实例化这个类的目的就是为了使用其对象作为项目全局配置对象，这样通过配置文件配置的信息可以保存在这个配置对象中，而这个配置对象在创建好之后是保存在 JVM 的 Heap 内存中的，方便随时读取。不然每次需要配置信息的时候都要临时从磁盘配置文件中获取，代码复用性差的同时，也不利于开发。

5.DefaultSqlSessionFactory: SqlsessionFactory 该 接 口 是 会 话 工 厂 ， 是 用 来 生 产 会 话 的 工 厂 接 口 ， DefaultSqlSessionFactory 是其实现类，是真正生产会话的工厂类，这个类的实例的生命周期是全局的，它只会在首次调用时生成一个实例（单例模式），就一直存在直到服务器关闭。

6.Executor: 执行器接口，SqlSession 会话是面向程序员的，而内部真正执行数据库操作的却是 Executor 执行器，通过 SqlSession 产生的数据库操作，全部是通过调用 Executor 执行器来完成的.Executor 是跟 SqlSession 绑定在一起的，每一个 SqlSession 都拥有一个新的 Executor 对 象，由 Configuration 创建.

7.StatementHandler:Statement处理器，封装了 Statement 的各种数据库操作方法 execute()。（ MyBatis 是将操作数据库的 JDBC 操作封装起来的一个框架，同时还实现了 ORM 。）

8.ResultSetHandler: 结果集处理器，如果是查询操作，必定会有返回结果，针对返回结果的操作，就要使用 ResultSetHandler 来进行处理，这个是由 StatementHandler 来进行调用的。这个处理器的作用 就是对返回结果进行处理。

1. SpringMVC的执行过程是什么? 有哪些常用类和接口,他们的作用是什么?

执行过程：

用户发起请求，请求被主控制器DispatchServlet捕获，Dispatch Servlet对URL进行解析，得到请求资源标识符URI，然后根据URI调用HandleMapping获得Hanlder配置的所有相关对象，包括Handler对象以及对象对应的拦截器，以HandlerExecutionChain的形式返回给DispatcherServlet，DispatcherServlet根据获得的Handler，通过HandlerAdapter处理器适配器调用处理器，HandlerAdapter执行完处理器向DispatcherServlet返回一个ModelAndView对象，DispatcherServlet将ModelAndView传给ViewResolver视图解析器，ViewResolver解析后返回具体的view对象，DispatcherServlet对view进行视图渲染，将渲染结果返回给客户端浏览器。

常用类和接口：

1.DispatcherServlet主控制器

1.1HttpServletBean：HttpServletBean 覆写了 init 方法，主要做一些初始化的工作，将 web.xml 中配置的参数 设置到 Servlet 中。比如 servlet 标签的子标签 init-param 标签中配置的参数

1.2FrameworkServlet：将 Servlet 上下文与 Spring 容器上下文关联。其实也就是初始化 FrameworkServlet 的属 性 webApplicationContext ， 这 个 属 性 代 表 SpringMVC 上 下 文 对 象 ， 实 际 类 型 ConfigurableWebApplicationContext。如果项目中用到spring了那么它有个父容器，既web.xml 中配置的 ContextLoaderListener 监听器初始化的容器上下文

2.HandlerMapping接口：作用是根据当前请求的找到对应的 Handler（HandlerMethod(Controller 中的方法)、 Controller 对 象 ） ， 并 将 Handler 与 一 堆 HandlerInterceptor （ 拦 截 器 ） 封 装 到 HandlerExecutionChain 对象中。在 HandlerMapping 接口的内部只有一个方法： HandlerExecutionChaingetHandler(HttpServletRequestrequest);

2.1HandlerMapping 接口实现类 ：HandlerMapping 实现类有两个分支，分别继承自 AbstractHandlerMethodMapping（得 到 HandlerMethod）和 AbstractUrlHandlerMapping（得到 Controllert），它们又统一继承于 AbstractHandlerMapping。

3.HandlerAdapter 接口：SpringMVC 中使用适配器模式来解决不同的 Handler 的执行。根据 Handler 来找到支持它的 HandlerAdapter，通过 HandlerAdapter 执行这个 Handler 得到 ModelAndView 对 象。

3．1接口中的抽象方法：

booleansupports(Objecthandler); 判断是否支持传入的 Handler ModelAndView

handle(HttpServletRequest request, HttpServletResponse response, Object handler) 用来使用 Handler 处理请求

long getLastModified(HttpServletRequest request, Object handler); 用 来 获 取 资 料 的 Last-Modified 值

3.2AbstractHandlerMethodAdapter 抽象类：利用 RequestMappingHandlerMapping 获取的 Handler 是 HadnlerMethod 类型，它代 表 Controller 里要执行的方法。handlerInternal 是子类 RequestMappingHandlerAdapter 中的 方法。

3.3RequestMappingHandlerAdapter 类：RequestMappingHandlerAdapter 实际就是执行@RequestMapping 注解的方法

3.4HttpRequestHandlerAdapter 类：HttpRequestHandlerAdapter 。 是 HttpRequestHandler 的 适 配 器 可 以 执 行 HttpRequestHandler 类型的 Handler。其实就是 Controller 中的 handleRequest 方法

3.5SimpleControllerHandlerAdapter 类：SimpleControllerHandlerAdapter 是 Controller 实现类的适配器类，其本质也是执行 Controller 中的 handleRequest 方法。

3.6SimpleServletHandlerAdapter 类：SimpleServletHandlerAdapter 其实是一个 Servlet 的适配器，其最终执行的方法是 Servlet 的 service 方法

4．ViewResolver 接口：根据视图的名称将其解析为 View 类型的视图，如通过 ModelAndView 中的视图名称 将其解析成 View，View 是用来渲染页面的，也就是将 Model 填入模板中，生成 html 或 其他格式的文件。

4.1AbstractCachingViewResolver 抽象类：AbstractCachingViewResolver 是带有缓存的 ViewResolver，它每次解析时先从缓存里查找，如果找到视图就返回，没有就创建新的视图，且创建新视图的方法由其子类实现。

4.2ResourceBundleViewResolver 类：ResourceBundleViewResolver 根据 views.properties 文件来解析视图，这个文件应位于 classpath 路径下

4.3XmlViewResolver 类：XmlViewResolver 根据 xml 文件来解析视图

4.4UrlBasedViewResolver 类：UrlBasedViewResolver 提供了拼接 URL 的方式来解析视图，通过 prefix 属性拼接一 个前缀，通过 suffix 属性拼接一个后缀，就得到了视图的 URL。还可以加入 redirect: 与 forword: 前缀，使用 redirect: 前缀会调用 HttpServletResponse 对象的 sendRedirect() 方法 进行重定向，使用 forword: 前缀会利用 RequestDispatcher 的 forword 方式跳转到指定的地 址。另外，使用时还要指定 viewClass 属性，表示要解析成哪种 View。

4.5InternalResourceViewResolver 类：InternalResourceViewResolver 是 UrlBasedViewResolver 的 子 类 ， 将 InternalResourceView 作为默认的 View 类，但如果当前 classpath 中有 jstl 的 jar 包时则 使用 JstlView 作为 view 来渲染。

5.View接口：视图渲染器，在该接口中定义了渲染视图的抽象方法。 何为渲染：所谓渲染其实就是将 Model 中的数据放到 HttpServletRequest 中传递 jsp。 void render(Map<String, ?> model, HttpServletRequest request, HttpServletResponse response)throwsException;

5.1InternalResourceView 类：继承自 AbstractUrlBasedView 抽象类的类，表示 JSP 视图

1. Spring有哪些常见类和接口,他们的作用是什么?

1.ApplicationContext: ApplicationContext内部封装了一个BeanFactory对象，来实现对容器的操作， BeanFactory 封装了 bean 的信息，而 ApplicationContext 通过访问 BeanFactory 对象获取 bean 的对象信息 ApplicationContext 也实现了一系列的 BeanFactory 接口(可以说 ApplicationContext 对 BeanFactory 对象实现一种代理)。

2.ClassPathXmlApplicationContext:

refresh:初始化IOC容器

DefaultListableBeanFactory：在 BeanFactory 子类中有一个 DefaultListableBeanFactory 类，它包含了基本 Spirng IoC 容器所具有的重要功能，开发时不论是使用 BeanFactory 系列还是 ApplicationContext 系列来 创建容器基本都会使用到 DefaultListableBeanFactory 类，可以这么说，在 spring 中实际上把 它当成默认的 IoC 容器来使用

3.XmlBeanDefinitionReader:解析xml配置文件

4.beanDefinitionMap：将BeanDefinition注册到容器中

5.preInstantiateSingletons:实例化Bean对象

6.getObjectForBeanInstance:获取Bean对象

SpringData

1. 讲一讲你对现在公司里常见的持久化框架的理解

目前公司里常见的持久层框架由Hibernate和Mybatis两种。

Hibernate:

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。 Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

Mybatis:

使用MyBatis 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象， 这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate 会自动生成SQL 语句，而MyBatis则要求开发者编写具体的SQL 语句。相对Hibernate等 "全自动"ORM机制而言，MyBatis 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。作为"全自动"ORM 实现的一种有益补充，MyBatis 的出现显得别具意义。

1. 什么是JPA?为什么每个持久化框架都要实现JPA标准?

JPA：

JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象-关系表的映射关系，并将运行期的实体对象持久化到数据库中。

持久层框架实现JPA标准出于两个原因:

其一，简化现有Java EE和Java SE应用开发工作;

其二，Sun希望整合ORM技术，实现天下归一。

1. Spring如何整合hibernate?

<!--c3p0数据库连接池-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="jdbcUrl" value="${jdbc.url}"/>
<property name="driverClass" value="${jdbc.Driver}"/>
<property name="user" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!--Hibernate的Session Factory-->
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--配置与hibernate相关的内容，如显示sql语句，开启正向工程-->
<property name="hibernateProperties">
<props>
<!--显示当前执行的sql语句-->
<prop key="hibernate.show_sql">true</prop>
<!--开启正向工程-->
<prop key="hibernate.hbm2ddl.auto">update</prop>
</props>
</property>
<!--扫描实体所在的包-->
<property name="packagesToScan">
<list>
<value>com.bjsxt.pojo</value>
</list>
</property>
</bean>
<!--配置HibernateTemplate对象-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate5.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!--Hibernate的事物管理器-->
<bean id="transactionManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!--开启注解事务处理-->
<tx:annotation-driven transaction-manager="transactionManager"/>
<!--Spring IOC的注解扫描-->
<context:component-scan base-package="com.bjsxt"/>

1. 说说你对SQL和HQL的理解

sql是面向数据库表查询，格式：from + 表名 + where + 表中字段

hql是面向对象查询，格式：from + 类名 + 类对象 + where + 对象的属性

查询：

hql查询提供了更加丰富的和灵活的查询特性，在涵盖 Criteria查询的所有功能的前提下，提供了类似标准SQL语句的查询方式，同时也提供了更加面向对象的封装。

sql只是结构化查询语言，只是面向数据检索，不具有面向对象的特征，所以HQL更加符合开发标准！

新增：hql不需要再用insert语句，只需构造新增对象后调用save()方法

修改：hql不需要再用update语句，只需得到修改对象后调用update()方法

删除：hql不需要再用delete语句，只需得到要删除的对象后调用delete()方法

1. 说说你对SpringDataJPA的理解

Spring Data JPA 是Spring Data 家族的一部分，它使得很容易实现基于 JPA 的存储库。 该模块处理对基于 JPA 的数据访问层的增强支持。 它使得构建使用数据访问技术的 spring 驱动的应用程序更加容易。

SpringData : Spring 的一个子项目。用于简化数据库访问，支持NoSQL 和 关系数据存储。其主要目标是使数据库的访问变得方便快捷。

SpringData 项目所支持 NoSQL 存储：

MongoDB （文档数据库）

Neo4j（图形数据库）

Redis（键/值存储）

Hbase（列族数据库）

SpringData 项目所支持的关系数据存储技术：

JDBC

JPA

JPA Spring Data ： 致力于减少数据访问层 (DAO) 的开发量， 开发者唯一要做的就只是声明持久层的接口，其他都交给 Spring Data JPA 来帮你完成！

Spring Data JPA 进行持久层(即Dao)开发一般分三个步骤：

1.声明持久层的接口，该接口继承 Repository（或Repository的子接口，其中定义了一些常用的增删改查，以及分页相关的方法）。

2.在接口中声明需要的业务方法。Spring Data 将根据给定的策略生成实现代码。

3.在 Spring 配置文件中增加一行声明，让 Spring 为声明的接口创建代理对象。配置了 <jpa:repositories> 后，Spring 初始化容器时将会扫描 base-package 指定的包目录及其子目录，为继承 Repository 或其子接口的接口创建代理对象，并将代理对象注册为 Spring Bean，业务层便可以通过 Spring 自动封装的特性来直接使用该对象。

1. 说说你对SpringDataRedis的理解

Spring-data-redis是spring大家族的一部分，提供了在srping应用中通过简单的配置访问redis服务，对reids底层开发包(Jedis, JRedis, and RJC)进行了高度封装，RedisTemplate提供了redis各种操作、异常处理及序列化，支持发布订阅，并对spring 3.1 cache进行了实现。