face to face

1.Spring的核心？

spring框架提供的两大核心是 : IOC和AOP。 ioc和aop是spring框架提供的用于实现对象管理的两种技术。

    IOC:全称 : inversion of control?直译为控制反转，其核心思想为依赖注入

    ioc是一种用于描述对象创建 及 对象依赖形成的一种技术。

        首先，ioc底层采用工厂模式实现，所以其首要目的-也就是工厂的目的-创建对象；但是ioc创建对象的方式和普通工厂不同，普通工厂是在工厂类中new对象；而ioc则是将需要其创建的对象配置在ioc容器中，使用工厂类解析ioc容器，然后以反射的方式创建对象。ioc的直译'控制反转'正是描述了ioc环境下对象创建的特点：将对象的创建权利从内部代码转移到外部容器，这个转移的过程即为反转。

        其次，ioc的核心思想则是他的被动注入。我们使用ioc的方式创建对象的目的就是为了采用其提供的被动注入思想，以此形成对象之间的依赖关系。ioc为了实现被动注入提供了setter、构造器和方法注入。

Spring整合hibernate中，获取HibernateTemplate实例就是采用的IOC被动注入

  AOP:全称 : aspect oriented programming 面向切面编程思想，底层采用代理模式实现的一种技术

        首先，AOP是OOP的一种延续思想，用于解决OOP开发过程中对象封装、继承、多态所造成的对象之间高度耦合性而提出的一种新的编程思想。

        AOP通过分离组成软件的核心业务逻辑和系统级服务进行内聚性开发。其关注点在于系统级服务部分。

        AOP的实现策略是将系统级服务封装成为一种AOP组件，采用XML配置及引用的方式将这个AOP组件所提供的系统级服务添加给需要该服务的核心业务逻辑。从而实现核心逻辑与通用服务之间的解耦。

        比如，spring中提供的声明式事务功能就是以AOP为基础而提出的一种技术。

        struts2内置的Interceptor 和 spring-mvc内置的HandlerInterceptor都属于AOP的实现技术。

2.Spring 事务

 2.1 (那你谈谈什么是事务，你的项目中哪里用到事务了)

   在一次请求过程中，对多次数据库的连接操作进行统一的提交或回滚操作，以此保证数据执行的一致性，或者是对多个sql语句进行统一的提交或回滚操作。比如涉及到批量添加、删除的操作，或者银行转账这种一次请求涉及多次数据库连接修改的操作。

 2.2 SPRING有哪些事务？

 spring提供了编程式事务支持 TransactionTemplate；也提供了声明式事务支持，底层采用AOP实现的事务通知bean，将事务的管理过程（包括事务对象的创建，提交和回滚操作）封装在一个事务通知bean中，然后通过配置AOP切入点的方式来描述需要将事务通知bean所提供的事务管理服务引用给哪些核心对象/方法。也有注解形式的 @Transactional；

    Spring的事务管理器有5个，都实现了PlatformTransactionManager接口，如下所示：

    DataSourceTransactionManager        JDBC事务管理器

    HibernateTransactionManager            Hibernate事务管理器

    JdoTransactionManager                JDO事务管理器

    JtaTransactionManager                JTA事务管理器

    PersistenceBrokerTransactionManager    Apache的OJB事务管理器

2.3 Spring的七种事务传播行为

  mandatory：支持当前事务，如果当前没有事务抛出异常

  never：不支持当前事务，如果当前有事务抛出异常

  not_support：不支持当前事务，总是以非事务环境运行

  required：支持当前事务，如果没有则创建一个新的（常用&&默认）

  requires_new：总是创建一个新事务，如果当前有事务则挂起当前事务

  supports：支持当前事务，如果当前没有则以非事务环境运行

  nested：如果当前有事务则把新事物作为原实物的内嵌事务进行执行；否则以required方式运行

3： spring如何整合hibernate

  在ioc容器中配置一个HibernateTemplate-Bean对象和SessionFactory实例，通过LocalSessionFactoryBean提供的setDataSource实现SessionFactory的配置过程！

4： spring如何整合struts

     使用spring的ioc容器管理struts中用于处理请求的Action

     将Action配置成ioc容器中的bean

     1）客户端提交的被struts拦截到的请求，通过struts.xml中的<action>元素来配置其映射关系，name属性指向请求名，class属性指向IOC容器中某个bean的ID值，表示使用该bean指向的处理器处理当前请求

     2）将action配置在ioc容器中之后，该action默认会在tomcat启动时初始化，并且初始化的单例状态为：单例（只维护一个Action实例处理多用户提交的请求）。区别于单独使用struts时客户端每次发送请求创建一个新的action处理。

     3）整合过程使用了struts2提供的插件 struts-spring-plugin.jar

5：spring如何整合mybatis

     使用spring的IOC容器管理mybatis的接口实例

     1）在ioc容器中配置mybatis核心对象SqlSessionFactory，使用工厂bean:SqlSessionFactoryBean,通过其提供的setDataSource()和setMapperResources()为该对象注入数据源和映射文件

     2）在ioc容器中配置用于扫描接口的工厂bean，通过扫描接口获取接口的实例bean：使用工厂bean:MapperScannerConfigurer，通过其提供的setBasePackage()和setSqlSessionFactoryBeanName()来设置需要扫描的包结构和SqlSessionFactory

6：Spring中如何使用redis【String list set sortedSet HashMap】

使用spring-data组件中提供的spring-data-redis，在spring支持下去操作缓存系统。
  使用过程：配置redis连接池 -> 配置jedis连接工厂 -> 配置用于封装连接过程的模板类对象（RedisTemplate） -> 调用jedis方法操作数据
7：Spring中做任务调度

JDK内置的Timer和TimerTask实现

1） 创建一个继承自TimerTask的对象作为任务对象；覆盖其提供的run()，在该方法中实现任务内容

2） 提供一个ServletContextListener用于监听tomcat的启动过程，当tomcat启动之后，在该监听器的初始化方法中，创建一个计时器对象

3） 通过计时器Timer对象加载任务对象的执行（同时设置执行的时间点或者执行的周期）弊端 : 只能对周期固定的任务进行调度！

spring集成的quartz框架实现

1） 提供一个普通的javaBean作为任务对象

2） 将任务对象配置成ioc容器中的bean对象，交给ioc容器管理

3） 描述任务细节(MethodInvokingJobDetailFactoryBean);配置任务对象以及其提供的任务方法(setTargetObject() setTargetMethod())

4） 配置触发器（CronTriggerFactoryBean）;为任务设置触发的时间或周期(setJobDetail() setCronExpression())

5 )  配置调度类(SchedulerFactoryBean）;在调度类中配置所有的触发任务（setTriggers()）    

8：Spring整合JDBC

spring整合jdbc：将流程封装在JdbcTemplate，通过对这个模板类的使用 实现对流程代替，在DAO的每个方法中 使用JdbcTemplate。dao层中获取JdbcTemplate实例。ioc被动注入的方式将JdbcTemplate注入给dao。在ioc中配置JdbcTemplate，还要为它提供一个DataSource。

9：Spring+Maven

本地安装apache-maven，配置maven环境变量 ： m2_home classpath path

修改配置文件，指向本地资源库 apache-maven/conf/settings.xml

命令控制台运行mvn命令，安装maven基础jar

eclipse中配置maven环境，指向本地安装的maven工具

创建maven工程,设置groupid（基础包结构），artifactId（工程名）

需要的jar包在pom.xml的dependencys元素下声明

10.WebService的使用

选择一种webservice技术发布 (cxf xfire ...)

     cxf发布方式[基于spring环境] :

     a 使用@WebService标注需要发布的接口和实现类

     b 在ioc容器中配置发布的过程 :

<cxf:server serviceClass="指向发布的接口" address="为发布的webservice配置一个唯一地址">

<cxf:serviceBean>

<bean class="指向发布的webservice接口实现类"/>

</cxf:serviceBean>

</cxf:server>

     c 配置用于接受webservice请求的接收器(web.xml)

<servlet>

<servlet-name>cxf</servlet-name>

<servlet-class>...CXFServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>cxf</servlet-name>

<url-pattern>/ws/*</url-pattern>

</servlet-mapping>

 '/ws/*' 表示告诉其他工程如何向本工程发送webservice请求，调用本工程提供的webservice接口。

11.Spring和Spring MVC作用域

 11.1：singleton (默认) prototype request session globalSession

      注意 ： global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

11.2：Spring框架中的单例Bean是线程安全的吗?

     是

     spring通过采用ThreadLocal解决线程安全问题

     Spring框架里的bean，获取实例的时候都是默认的单例模式。

          一般情况下，只有无状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程*享

      ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。 ThreadLocal采用的这种“以空间换时间”的方式，为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

11.3：使用springmvc是不是每次请求都创建一个controller对象

由于springmvc的请求处理是依存于IOC容器的，用于处理请求的controller也属于ioc容器中的bean

而ioc容器中bean对象的默认状态为单例状态【scope="singleton"】,所以默认情况下，spring-mvc只维护一个controller实例来处理多个客户端提交的请求。

当然，也可以将其设置为非单例状态，以保证每次请求都可以创建一个新的controller对象进行处理。只需要将controller对象的scope属性设置为prototype。或者使用@Scope注解

12.servlet的生命周期？
    init（）：在Servlet的生命周期中，仅执行一次init()方法。它是在服务器装入Servlet时执行的，
 负责初始化Servlet对象。可以配置服务器，以在启动服务器或客户机首次访问Servlet时装入Servlet。
 无论有多少客户机访问Servlet，都不会重复执行init（）。
    service（）：它是Servlet的核心，负责响应客户的请求。每当一个客户请求一个HttpServlet对象，
 该对象的Service()方法就要调用，而且传递给这个方法一个“请求”（ServletRequest）对象和一个“响应”
（ServletResponse）对象作为参数。在HttpServlet中已存在Service()方法。默认的服务功能是调用与HTTP请求
 的方法相应的do功能。
    destroy（）： 仅执行一次，在服务器端停止且卸载Servlet时执行该方法。当Servlet对象退出生命周期时，
 负责释放占用的资源。一个Servlet在运行service()方法时可能会产生其他的线程，因此需要确认在调用destroy()方法时，
 这些线程已经终止或完成

13.Spring MVC

 13.1 Spring MVC使用到的jar包

13.2Spring MVC配置文件以及配置mybatis配置文件

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	<!-- 扫描注解实例化和注入 -->
	<context:component-scan base-package="com.zbjk.order">
		<!-- springmvc会第二次扫描Controller注解。第一次spring不需要扫描Controller注解-->
		<context:exclude-filter type="annotation" 
			expression="org.springframework.stereotype.Controller"/>
	</context:component-scan>
	<!-- 导入配置文件 -->
	<context:property-placeholder location="classpath:properties/*.properties" />
	
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/aop
	http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
	http://www.springframework.org/schema/mvc
	http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-4.0.xsd">
	<!-- 1.扫描注解 -->
	<context:component-scan base-package="com.zbjk.order">
		<!-- 事务只配置在spring里面，在Service层注入。
			spring第一次扫描Service注解会注入事务，springmvc第二次扫描会覆盖Service注解，没有事务
	    -->
		<context:exclude-filter type="annotation" 
			expression="org.springframework.stereotype.Service"/>
	</context:component-scan>
	<!-- 2.解析映射器和适配器、json转换等信息 -->
	<mvc:annotation-driven></mvc:annotation-driven>
	<!-- 地址栏直接输入工程名，指定跳的页面 -->
	<mvc:view-controller path="/" view-name="login"/>
	<!-- 处理restfull风格，不解析css/js -->
	<mvc:resources location="/skin/" mapping="/skin/**"/>
	<!-- 3.配置视图解析器 -->
	 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	 	<!-- 可以不用写，默认就是 -->
	 	<property name="viewClass" value="org.springframework.web.servlet.view.JstlView"></property>
	 	<property name="prefix" value="/pages/"></property>
	 	<property name="suffix" value=".jsp"></property>
	 </bean>
</beans>

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
	http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
	http://www.springframework.org/schema/context
	http://www.springframework.org/schema/context/spring-context-4.0.xsd
	http://www.springframework.org/schema/tx
	http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
	<!-- 1.数据源 -->
	<bean id="dataSource" 
		class="org.springframework.jdbc.datasource.DriverManagerDataSource">
		<property name="driverClassName" value="${jdbc.driverClassName}"></property>
		<property name="url" value="${jdbc.url}"></property>
		<property name="username" value="${jdbc.username}"></property>
		<property name="password" value="${jdbc.password}"></property>
	</bean>
	<!-- 2.mabatis工厂 -->
	<bean id="sqlSessionFactory" 
		class="org.mybatis.spring.SqlSessionFactoryBean">
		<property name="dataSource" ref="dataSource"></property>
		<property name="configLocation" value="classpath:mybatis/mybatis.cfg.xml"></property>
	</bean>
	<!-- 3.扫描接口并实例化接口  -->
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<property name="basePackage" value="com.zbjk.order.mapper"></property>
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"></property>
	</bean>
	<!-- 4.配置事务管理器 -->
	<bean id="tx" 
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<property name="dataSource" ref="dataSource"></property>
	</bean>
	<!-- 5.使用注解方式使用事务 -->
	<tx:annotation-driven transaction-manager="tx" />
</beans>

1，用户发送请求到springmvc框架提供的DispatcherServlet 这个前端控制器(了解struts2的朋友也都知道其实struts2也有一个前端控制器web.xml中的filter标签就是)
2，前端控制器会去找处理器映射器(HandlerMapping)，处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet 。
3，根据处理器映射器返回的处理器，DispatcherServlet 会找“合适”的处理器适配器(HandlerAdapter)
4，处理器适配器HandlerAdpater会去执行处理器(Handler开发的时候会被叫成controller 也叫后端控制器在struts2中action也是一个后端控制器)执行之前会有转换器、数据绑定、校验器等等完成上面这些才会去正在执行Handler
5，后端控制器Handler执行完成之后返回一个ModelAndView对象
6，处理器适配器HandlerAdpater会将这个ModelAndView返回前端控制器DispatcherServlet。前端控制器会将ModelAndView对象交给视图解析器ViewResolver。
7，视图解析器ViewResolver解析ModelAndView对象之后返回逻辑视图。
8，前端控制器DispatcherServlet对逻辑视图进行渲染(数据填充)之后返回真正的物理View并响应给浏览器。

13.3 Spring MVC和Struts2的区别

1、springmvc基于方法开发的，struts2基于类开发的。springmvc将url和controller里的方法映射。映射成功后springmvc生成一个Handler对象，对象中只包括了一个method。方法执行结束，形参数据销毁。springmvc的controller开发类似web service开发。
2、springmvc可以进行单例开发，并且建议使用单例开发，struts2通过类的成员变量接收参数，无法使用单例，只能使用多例。
3、经过实际测试，struts2速度慢，在于使用struts标签，如果使用struts建议使用jstl。

===========================================================

1.描述B/S中的session机制和Cookie机制      

【HttpSession】由服务器创建，是web容器提供的一种安全性很高的会话跟踪机制，通过request.getSession()创建新的HttpSession(中文称之为会话)，支持中文。通过setAttribute(String,Object)封装数据，通过getAttribute(String)来拿取数据。HttpSession在创建后

开始进行倒计时，默认最大不活动周期为1800s（可以更改），在这期间如果用户再次提交请求，则重新倒计时。HttpSession是一段时间概念，我们无法从本地找到一个具体的HttpSession实体

HttpSession销毁的几种途径：

 1：超过最大不活动周期，在最大不活动周期到期后依然没有任何请求提交，则HttpSession销毁

 2：直接调用session.invalidate()立刻销毁当前已经存在的session

 3：关闭浏览器，注意关闭浏览器并不是严格意义上的销毁当前session，而是当我们重新打开浏览器时

   会再次分配给一个新的session，原来的老session无法获取了。

【Cookie】由服务器创建，是浏览器提供的一种会话跟踪机制，所有浏览器都支持cookie会话跟踪机制

cookie存在构造方法，直接可以在服务器端new出来，传递一个键值对，数据类型必须都为String，默认不

支持中文，一般我们将可以分辨权限的数据放置在cookie中用来对用户的权限等进行解析，当服务器返回响应时，cookie一并返回客户端，并最终保存在用户本地，我们从浏览器的设置中可以找到本地的cookie实体文件。

HttpSession和cookie是两种会话跟踪机制，表面上两者没有任何联系，HttpSession的应用场合一般较高，两者没有任何关系吗?答案是否定的，HttpSession并不能独立从一个页面传递到另外一个页面，一般情况下它是通过浏览器提供的cookie会话跟踪机制进行跳转的，

Cookie cookie = new Cookie("jsessionid",***) key为jsesssionid。value为session的id数

当开启的session会话跟踪机制后，cookie会自动帮助session进行传递，我们不需要手动进行设置。这也是为什么在禁用cookie后，HttpSession会话跟踪机制也会失效

禁用Cookie就无法维持Session会话跟踪机制了吗?

 String path = "/ServletDay4_cookie_session/servlet/TestSession2";

 //重写url

 String finalPath = response.encodeURL(path);

 response.sendRedirect(finalPath);

 通过response.encodeURL(路径)将sessionid封装进提交的url路径，则sessionid可以传递到新的页   面，从而web容器根据id提供的会话，这个会话就是在跳转前创建好的（因为id一致），从而继续维持   会话跟踪机制。

2.请说明FTP与SFTP协议的主要区别

 FTP是文件传输协议。在网站上，如果你想把文件和人共享，最便捷的方式莫过于把文件上传到FTP服务器上，其他人通过FTP客户端程序来下载所需要的文件。【ftp 192.168.0.100 get /interface/a.txt】

FTP进行文件传输需要通过端口进行。一般所需端口为：

1. 控制链路—TCP端口21。控制器端。用于发送指令给服务器以及等待服务器响应。

2. 数据链路---TCP端口20。数据传输端口。用来建立数据传输通道的。主要用来从客户向服务器发送一个文件、从服务器向客户发送一个文件、从服务器向客户发送文件或目录列表。

 SFTP是Secure File Transfer Protocol的缩写，是安全文件传送协议。可以为传输文件提供一种安全的加密方法。跟ftp几乎语法功能一样。SFTP是SSH的一部分，是一种传输档案至Blogger伺服器的安全方式。它本身没有单独的守护进程，必须使用sshd守护进程来完成相应的连接操作，所以从某种意义上来说，SFTP并不像一个服务器程序，而更像是一个客户端程序。SFTP同样是使用加密传输认证信息和传输的数据，所以使用SFTP是十分安全的。但由于这种传输方式使用了加密/解密技术，所以传输效率比普通的FTP要低得多。在对网络安全性要求更高时，代替FTP使用。

3.Tomcat作为常用的web服务器之一,请写出后台启动tomcat的过程以及实时监视cata..控件的命令

 【tomcat的原理】：

 当浏览器访问一个由tomcat搭建的web应用程序时，tomcat会把相应的文件，转换成浏览器能够显示的文件。浏览器访问的是一个jsp文件时，tomcat会把jsp文件编译成一个servlet，servlet再给浏览器发送相应的数据。只有第一次访问的时候才会编译成servlet以后访问就直接调用对应的servlet。当浏览器访问的是servlet和html时，tomcat就会直接传递给浏览器。

 初始化部分1：

   0. setCatalinaHome,setCatalinaBase，存入系统属性

   1. 装载配置文件(catalina.properties)，写入System.setProperty

   2. 创建classloader(common,server,shared),默认创建common classloader,三者都使用            StandardClassLoader(URL[])创建。common的parent classloader为null，且它将作为其他        两个的父classloader。

   3. 向MBeanServer注册classloader，交给MBeanServer管理

   4. setContextClassLoader(catalinaLoader),catalinaLoader即为server classloader。

   5. 如果可以获取到securitymanager，还要显示的对一些安全类进行预加载。

   6 启动org.apache.catalina.startup.Catalina，并调用他                              setParentClassLoader(sharedLoader)方法。

 初始化部分2：

   0.解析启动参数指令，并将相应的参数赋值到catalina类中，同时写入System.setProperty，事       实上，catalina是一个启动配置相关的脚本类。

   1. 初始化目录，实际上就是catalina_home,catalina_base之类。

   2.初始化命名系统（initNaming），即向System.setProperty注入java.naming.factory.initial       之类，用于上下文查询的工厂类是org.apache.naming.java.javaURLContextFactory

   3.解析server.xml配置文件——使用digester，解析配置文件中的层次结构，并将关系注入到对应       的类中。创建connector时创建protocolhandler

   4. 初始化standardserver，初始化阶段会触发fireLifecycleEvent，如果在外围注入相应的          listner就可以监听事件

   5. 注册standardserver到MBeanServer

   6. 初始化service服务,

   7. 注册standardservice到MBeanServer

   8. 初始化connector

   9. 注册connector到MBeanServer

   10. 初始化protocolHandler

   11. 初始化endpoint(底层socket初始化等)

 开启部分：

   0. 启动standardserver启动阶段会触发fireLifecycleEvent，如果在外围注入相应的listner就       可以监听事件

   1. 启动service服务,启动阶段会触发fireLifecycleEvent，如果在外围注入相应的listner就可       以监听事件

   2.启动（也包含了init）container（这里指engine）,顺便启动（也包含了init）Realm,然后一       次初始化（也包含了init）child加container（这里主要是host）

     接下来启动StandardPipeline，其主要工作是将pipeline中的value注册到MBeanServer中，默       认只有一个basic value，它在调用standardengine构造函数时被设置。

     最后，启动container的后台线程ContainerBackgroundProcessor，它所做的工作在              ContainerBackgroundProcessor类中

   3. 启动executors

   4.启动connector，将protocolHandler注册到MBeanServer。初始化mapperListener并将它注册到       MBeanServer。初始化MBeanServer主要做以下工作：registerEngine，registerHost           registerContext，registerWrapper等和具体的web应用模块相关的问题。

   5. 启动protocolHandler将endpoint和GlobalRequestProcessor注册到MBeanServer。

   6. 启动endpoint，启动worker，acceptor线程

4.什么是ajax？ajax请求的时候get和post的区别？

  AJAX即“Asynchronous Javascript And XML”（异步JavaScript和XML），是指一种创建交互式的快速动态网页的技术。通过在后台与服务器进行少量数据交换，AJAX 可以使网页实现异步更新。这意味着可以在不重新加载整个网页的情况下，对网页的某部分进行更新。传统的网页（不使用 AJAX）如果需要更新内容，必须重载整个网页。

区别:

1.get请求需注意缓存问题,post请求不需担心这个问题

2.post请求必须设置Content-Type值为application/x-form-www-urlencoded

3.发送请求时,因为get请求的参数都在url里,所以send函数发送的参数为null,而post请求在使用send方法时,却需赋予其参数

5.JSP九种内置对象：request, response, session, application, page, pageContext, out, exception, config。

1.request对象

客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应。它是HttpServletRequest类的实例

2.response对象

response对象包含了响应客户请求的有关信息，但在JSP中很少直接用到它。它是HttpServletResponse类的实例。

3.session对象

session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止。它是HttpSession类的实例.

4.out对象

out对象是JspWriter类的实例,是向客户端输出内容常用的对象

5.page对象

page对象就是指向当前JSP页面本身，有点象类中的this指针，它是java.lang.Object类的实例

6.application对象

application对象实现了用户间数据的共享，可存放全局变量。它开始于服务器的启动，直到服务器的关闭，在此期间，此对象将一直存在；这样在用户 的前后连接或不同用户之间的连接中，可以对此对象的同一属性进行操作；在任何地方对此对象属性的操作，都将影响到其他用户对此的访问。服务器的启动和关闭 决定了application对象的生命。它是ServletContext类的实例。

7.exception对象

exception对象是一个异常对象，当一个页面在运行过程中发生了异常，就产生这个对象。如果一个JSP页面要应用此对象，就必须把isErrorPage设为true，否则无法编译。他实际上是java.lang.Throwable的对象

8.pageContext对象

pageContext对象提供了对JSP页面内所有的对象及名字空间的访问，也就是说他可以访问到本页所在的SESSION，也可以取本页面所在的application的某一属性值，他相当于页面中所有功能的集大成者，它的本 类名也叫pageContext。

9.config对象

config对象是在一个Servlet初始化时，JSP引擎向它传递信息用的，此信息包括Servlet初始化时所要用到的参数（通过属性名和属性值构成）以及服务器的有关信息（通过传递一个ServletContext对象）

6.get和post区别 怎么用

  get:默认不支持中文，通过浏览器url进行传递值。?key=value&key=value最多传递256个字符，速       度快，安全性低下，一般链接肯定是get请求

  post:支持中文，通过消息体进行值得传递，无法从地址栏查询传递的值，没有大小限制，速度慢，       但是安全性较高，一般上传操作必须使用post

7.重定向与请求转发的区别

重定向：它就是由浏览器再一次转发，不再是同一次请求所以request范围失效，浏览器地址栏显示最终的目的地，跳转之前是do***，而跳转之后一定是doGet，因为浏览器优先使用Get请求（response.sendRedirect("/工程名/servlet/类名")；response.ssendRedirect("工程名/***.html")）。
请求转发：它是由servlet再次转发浏览器地址栏不显示最终目的地，因为不是浏览器自己发的所以他不知道最终的目的地在哪。是同一次请求，request范围有效，跳转之前是do***，跳转之后依然是do***（ request.getRequestDispatcher("类名").forword(request,response)）

8.页面会话保持

客户端方面保持：

①Session机制

②Cookie机制

• 登录验证后，创建登录凭证（比如：用户id+登录时间+过期时间），将登录凭证进行加密（为了避免暴露信息），加密后写到浏览器的cookie，以后，每次请求都发送cookie，服务器根据对应的解密算法对其进行验证（或者将加密过的cookie内容存储到数据库，请求服务器的时候，服务器在数据库进行查找）。

③Token机制

Tomcat会话保持：

1、session sticky：通过负载均衡器的负载均衡算法比如：源地址hash 和cookie

2、session cluster： session的共享存储  登陆信息存储在数据库

通过定义集群 Cluster 节点   DeltaManager会话管理器全节点复制同步所有会话

缺点：适合小规模 ，集群中 一台更新其他的也要更新session 组播复制给集群所有节点 

3、session serve： 通过内存级别非关系型数据库实现

使用Nginx反向代理会话保持

ip_hash：

ip_hash使用源地址哈希算法，将同一客户端的请求总是发往同一个后端服务器，除非该服务器不可用。

sticky_cookie_insert：

使用sticky_cookie_insert启用会话亲缘关系，这会导致来自同一客户端的请求被传递到一组服务器在同一台服务器。与ip_hash不同之处在于，它不是基于IP来判断客户端的，而是基于cookie来判断。因此可以避免上述ip_hash中来自同一局域网的客户端和前段代理导致负载失衡的情况。