JSP+Servlet 重要知识点 (含面试题）

JSP是Servlet技术的扩展，本质上就是Servlet的简易方式。JSP编译后是“类servlet”。

这里提一句：
jsp已经没有深入学习的必要了，除了维护老项目能用上一些，基本属于被淘汰的边缘了。Servlet还是有必要学习一下，比如spring mvc ,structs2等大部分java web框架都是基于Servlet体系来构建的。Servlet Api是这些上层框架的基石。

JSP与Servlet 知识点

IDEA 配置Tomcat ，详情见之前的文章
JSP：(java server pages)服务器端脚本，由html和嵌入式java组成。简单易用，完全面对对象。
Java Servlet是服务器端技术，通过提供对动态响应和数据持久性的支持来扩展Web服务器的功能。

首先客户端向web服务器提出请求，然后JSP负责将页面转化为Servlet，Servlet经过虚拟机编译成类文件，再把类文件加载到内存中执行，最后由服务器将处理结果返回给客户端。

Tomcat 目录结构

<%-- 注释内容 --%> 
<%!
	// 写java 代码
    int x,y=60;
    String name = "Joah";
    int chengji(int m,int n) {
    	return m*n;
    }
 %> 
 # 在JSP页面生成Servlet 引入需要包含的页文件，可以是html文件或者JSP文件。在编译时导入
<%@ include file="url"%>

# param:转发请求到另一个页面，请求过程中会连同请求的参数数据一起被转发到目标页面中。
<jsp:forward page="rel url" />
page="<%=url %>"
<jsp:param name="参数名称" value="李四"/>

main.jsp:

<jsp:include page="sub.jsp">
	<jsp:param value="Joan" name="username"/>
</jsp:include>

sub.jsp:
<%
   String username = request.getParameter("username")
   %>

<td>用户名: <%=uername%></td>

请求参数（重要）
浏览器地址栏输入 ?name=jacin&city=shanghai

<%
  String name = request.getParameter("name");
  String city = request.getParameter("city");
  if(name != null && city != null) {
%>
<p> Welcome <%=name%>,你的城市是<%=city%></p>
<%

}else {
%>

在form中，两个重要的属性：action (提交的页面）和method （post)。
表单写法：
注意 submit 的提交，

 <form  action="index.jsp" method="post">
        <table align="center">
            <tr>
                <td>姓名</td>
                <td><input type="text" name="name" value="" /></td>
            </tr>
            <tr>
                <td>城市</td>
                <td><input type="text" name="city" value="" /></td>
            </tr>
            <tr>
                <td><input type="submit" value="提交" /></td>
            </tr>
            <tr>
                <td><input  type="reset" value="重置"/></td>
            </tr>
        </table>

    </form>

# 在取得参数后，通过转码方式转为合适的字符集
String name = new String(request.getParameter("name").getBytes("ISO-8859-1")
#设置页面重定向
重定向指一个页面在收到一个访问请求后，根据请求的url重新跳转到其他页面。

<%
	response.sendRedirect("sendPage.jsp")
%>

web应用中，Servlet是一个重要的技术，其利用Java类编写的服务端程序，与架构、协议无关。JSP实质就是Servlet，因为JSP页面传回服务端都转为Servlet 进行编译，运行。由于JSP 编写HTML直观，所以也在逐步取代Servlet。

Servlet 生命周期
有3个阶段，分别是init ,service ,destroy
init (初始化）：分为装载和初始化。装载一个Servlet 类到Java内存。调用Init方法，只调用一次。
运行阶段：响应客户端的请求，有请求创建HttpServletRequest (/Response),调用service 方法。
消亡阶段，调用destroy，释放所占的资源。例如关闭流，关闭连接等。

这是HelloServlet 的一个例子：

import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

# 注解写法，这样子可以不用web.xml
//@WebServlet(
//        urlPatterns = {"/HelloServlet"}, 
//        name = " helloServlet"
//)
public class HelloServlet extends HttpServlet {
    private  static  final long serialVersionUID = 1L;

    @Override
    public void init() throws ServletException{
        System.out.println("初始化 init 方法"); 
    }

       
    @Override
    public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
        super.service(req, res);
        System.out.println("调用service 方法");
        res.setContentType("text/html;charset=gbk");
        PrintWriter out = res.getWriter();
        out.println("收到service请求");
    }

    @Override
    public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {
        System.out.println("调用doGet方法");
        response.setContentType("text/html;charset=gbk");
        PrintWriter out = response.getWriter();
        out.println("收到doGet请求");
    }

    @Override
    public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,IOException {
        System.out.println("调用doPost方法");
        response.setContentType("text/html;charset=gbk");
        PrintWriter out = response.getWriter();
        out.println("收到doPost请求");
    }
// 法二：编写前进页面：
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String userName = request.getParameter("username");
        String passwd = request.getParameter("passwd");
        if(checkLogin(userName,passwd)) {
            request.getRequestDispatcher("/member.htm").forward(request,response);
        }else {
        // 返回页面
            response.sendRedirect("login.jsp");
        }
    }


// 
    @Override
    public void destroy() {
        System.out.println("destroy");
    }
}

如果不使用注解，也可以使用web.xml配置：

   <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/HelloServlet</url-pattern>
    </servlet-mapping>

最后只要在网站中 加入/HelloServlet 即可运行。
Web容器显示：

监听器：
监视行为。监听事件来监听请求中的行为而创建的一组类。实现相应的监听接口。触发监听事件，应用服务器会自动调用监听方法。

<listener>
	<listener-class>
    	MyServletContextListener
    </listener-class>
</listener>

// 或者利用注入的方式注入监听类
@WebListener
@WebListener
//ServletContextListener：生命周期监听器，用来监听web初始化或者结束时响应的动作事件。
public class MyServletContextListener implements ServletContextListener {
    Logger log =Logger.getLogger("MyServletContextListener");
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        //获得对象
        ServletContext context = servletContextEvent.getServletContext();
        String name = context.getInitParameter("username");
        System.out.println(name+"实现接口");
        log.debug("初始化name"+name);
        log.debug("Tomcat启动中"); //使用的是log4j 1.2 jar
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        log.debug("Tomcat关闭");
    }
}

过滤器：
作用是阻挡某些事情的发生。在服务器端与客户端起到了一个中间组件的作用，对二者之间的数据进行过滤。
在Servlet实现过滤器，必须实现Filter接口，并用注入的方式或者在web.xml定义过滤器

//注入方式
@WebFilter(
	filterName = "myfilter",
    servletNames = {"*.do"},
    urlPatterns = {"/*"},
    initParams = {
        @WebInitParam(name = "param" , value = "paramvalue")
    },
    dispatcherTypes = {DispatcherType.REQUEST}
)

#web.xml 配置：
<filter>
	<description>demo</description>
    <filter-name>myfilter</filter-name>
    <filter-class>Myfilter</filter-class>
    
    <init-param>
    	<param-name>param</param-name>
        <param-value>paramvalue</param-value>
    </init-param>
</filter>

<!--过滤器映射配置-->
<filter-mapping>
	<filter-name>myfilter</filter-name>
    <servlet-name>*.do</servlet-name>
    <url-pattern>/*</url-pattern>
    <dispatcher>REQUEST</dispatcher>
</filter-mapping>

DAO 设计模式，降低耦合度，易于理解，也是非常容易入门的设计模式。（常见的JSP 设计模式）
JSP 使用Bean ：
在JSP页面中使用Bean:1.规范定义Bean，给出get 和set 2.在页面中导入Bean类。 3.利用jsp:useBean使用Bean类
规范定义Bean类：新增一个类就可以。一种将Bean的class文件部署在Web服务器公共目录中；另一种将Class文件部署在特定目录，Web-INF\classess
在JSP页面中导入相应的Bean类：
在src中定义类

<jsp:useBean id="product" class ="BeanTest.Product" scope="page"/>
scope表示在当前页有效
引入数据
<%=id.getName()%>

客户层—显示层—业务层—数据层—数据库
客户层：客户端浏览器
显示层：利用JSP和Servlet进行页面显示
业务层：对数据层原子性DAO操作进行整合
数据层：数据增删改查
数据库：保存数据库信息
DAO：Data Access Object。主要是对数据进行操作，对于上面层级就是数据层。在数据操作中，主要以面向接口编程为主。一般DAO分为：
VO(Value Object),DatabaseConnection，DAO-implements,DAOImpl,DAOproxy,DAOFactory
DAO命名规则：XxxDAO.

面试题

1.什么是JSP？它与Servlet有何不同？

JSP是JavaServer Pages的缩写，是一种用于构建动态Web页面的Java技术。
与Servlet不同，JSP允许将HTML代码与Java代码混合在同一文件中，使页面开发更容易和更具可读性。

2.JSP的生命周期是什么样的？

1.编译
JSP文件在第一次访问时会被编译成Servlet。编译的过程包括三个步骤：解析JSP文件。将JSP文件转为servlet。编译servlet。
2.初始化
容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法，也就是Servlet实例化并初始化。
如果你需要执行自定义的JSP初始化任务，复写jspInit()方法就行了。
3.JSP执行
当JSP网页完成初始化后，JSP引擎将会调用jspService()方法，处理客户端请求。jspService()方法：需要一个HttpServletRequest对象和一个HttpServletResponse对象作为它的参数 。jspService()方法：在每个request中被调用一次并且负责产生与之相对应的response，并且它还负责产生所有7个HTTP方法的回应，比如GET、POST、DELETE等等。
4.销毁
在Servlet容器关闭或JSP文件被修改时销毁。当你需要执行任何清理工作时复写jspDestroy()方法，比如：释放数据库连接或者关闭文件夹等等。

3.JSP的处理过程？

主要包含以下过程：
就像其他普通的网页一样，首先浏览器发送一个 HTTP 请求给服务器。
Web 服务器识别出这是一个对 JSP 网页的请求，并且将该请求传递给 JSP 引擎，通过使用 URL或者 .jsp 文件来完成。
JSP 引擎从磁盘中载入 JSP 文件，然后将它们转化为 Servlet。
JSP 引擎将 Servlet 编译成可执行类，并且将原始请求传递给 Servlet 引擎。
Web 服务器的某组件将会调用 Servlet 引擎，然后载入并执行 Servlet 类。
在执行过程中，Servlet 产生 HTML 格式的输出并将其内嵌于 HTTP response 中上交给 Web 服务器。
Web 服务器以静态 HTML 网页的形式，将 HTTP response 返回到您的浏览器中。
最终，Web 浏览器处理 HTTP response 中动态产生的HTML网页，就好像在处理静态网页一样。

4.jsp有哪些内置对象作用分别是什么

JSP共有以下9种基本内置组件（可与ASP的6种内部组件相对应）：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet 正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外

5. jsp有哪些动作作用分别是什么

JSP共有以下6种基本动作
jsp:include：在页面被请求的时候引入一个文件。
jsp:useBean：寻找或者实例化一个JavaBean。
jsp:setProperty：设置JavaBean的属性。
jsp:getProperty：输出某个JavaBean的属性。
jsp:forward：把请求转到一个新的页面。
jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

6.JSP 和 Servlet 有哪些相同点和不同点，他们之间的联系是什么？

JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。JSP编译后是"类servlet"。Servlet和JSP最主要的不同点在于，**Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离开来。**而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。

7.静态导入与动态导入区别？

静态包含在翻译的时候，将多个JSP合并翻译成了一个Servlert，动态包含在翻译的时候，每个JSP文件都翻译成了对应Servlet，在程序运行加载到JVM中的时候动态合并，动态包含可以传递参数。

<%@include file="validate.jsp" %>
将被导入页面和导入页面，合在一起进行翻译，编译。最后产生一个Servlet，那么两个页面的变量名不能重复。

<jsp:include page="validate.jsp"></jsp:include>
动态导入，被导入页面和导入页面分别翻译，编译，产生两个Servlet，所以两个页面的变量名可以重复.都会被执行。

8.JSP四种作用域

四种作用域包括page、request、session和application，具体来说：

page代表与一个页面相关的对象和属性。
request代表与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面，涉及多个Web组件；需要在页面显示的临时数据可以置于此作用域。
session代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。
application代表与整个Web应用程序相关的对象和属性，它实质上是跨越整个Web应用程序，包括多个页面、请求和会话的一个全局作用域。

9.<%…%>和<%!…%>的区别

<%…%>用于在JSP页面中嵌入Java脚本

<%!…%>用于在JSP页面中申明变量或方法，可以在该页面中的<%…%>脚本中调用，声明的变量相当于Servlet中的定义的成员变量。

10.servlet的生命周期

当服务器启动的时候生命周期开始，然后通过init()，方法初始化servlet，再根据不同请求调用doGet或doPost方法，最后再通过destroy()方法进行销毁。

11.get和post的区别

在页面提交数据时，get的数据大小有限制4k,post没有限制，get请求提交的数据会在地址栏显示，post不显示，所以post比get安全。

12.404和500是什么意思

404 ：找不到url请求的路径,一般是工程名不对或者拼写错误，500 ：服务器内部错误,一般是服务器内部代码编写错误,也有可能是抛异常导致。