标签：
1.部署并启动tomcat服务器
1). 解压tomcat安装包到一个非中文目录下
2). 配置一个环境变量 java_home（指向jdk安装的根目录）或jre_home
3). 通过tomcat安装目录bin目录下的startup.bat，启动服务器
4). 可以在浏览器中输入localhost:8080来检验Tomcat安装是否正确
5). 若已经启动了一个Tomcat应用，若再启动同一个Tomcat应用，会抛出异常：
Java.net.BindException:Addresss aleady in use:JVM_Bind:8080
端口已经被占用
2.Tomcat：开源的Servlet容器
3.可以通过修改server.xml文件中的配置信息来修改Tomcat服务器的端口号：
<Connector port="8080" protocol="HTTP/1.1"
connectionTimeout="20000"
redirectPort="8443" />
把port的值修改为其他的端口号即可
4. 为了可以在任意目录下启动Tomcat服务器
4.1 把D:\Program Files\apache-tomcat-7.0.37\bin 添加到path下
添加成功后，若在任意目录下通过startup其中Tomcat服务器，会有提示：
The catalina_home environment variable is not defined correctly
This environment variable is needed to run this program
即：要求设置CATALINA_HOME这个环境变量
5. 设置CATALINA_HOME环境变量
5.1 通过阅读stratup.bat批处理文件，可知CATALINA_HOME环境变量下有一个bin目录，而bin目录下又有一个catalina.bat文件，由此可知CATALINA_HOME指向的应该是Tomcat安装的根目录
于是吧Tomcat的根目录设为CATALINA_HOME环境变量
此时既可以在任意目录下用过startup.bat shutdown.bat启动、关闭服务器
6.继续阅读stratup.bat批处理文件，发现启动Tomcat服务器的是catalina.bat文件
在命令行窗口直接输入catalina，提示如下：
commands:
debug Start Catalina in a debugger
debug -security Debug Catalina with a security manager
jpda start Start Catalina under JPDA debugger
run Start Catalina in the current window
run -security Start in the current window with security manager
start Start Catalina in a separate window
start -security Start in a separate window with security manager
stop Stop Catalina
configtest Run a basic syntax check on server.xml
version What version of tomcat are you running?
Catalina命名有如上的可选参数
Run：在catalina同一个命令行窗口下启动服务器
Start：开启一个新窗口启动服务器
Stop：关闭服务器
7.第一个WEB应用程序：开发，并部署到Tomcat服务器下运行
1). 在Eclipse新建一个Java Project
2). 在Java项目下创建Web开发的目录结构
-WebContent
-WEB-INF
-classes（编译后的class文件必须放在此目录下）
-lib
-web.xml（从D:\Program Files\apache-tomcat-7.0.37\webapps\docs\WEB-INF拷贝过来，可以不做修改）
HTML页面
JSP页面
图片…
3). 在src下新建一个Person类
Package com.atguigu.test;
Public class Person{
Public String getPersonInfo(){
Return “Person info…”;
}
}
4). 手工把Person类对应的class文件（含包）复制到classes目录下
可以通过修改默认的输出目录达到自动把编译好的class放到classes目录下
5). 在webcontent目录下新建一个JSP文件：
%@page import="com.centfor.test.Person"%
<%
Person p = new Person();
System.out.print(p.getPersonInfo());
%>
6). 把WebContent目录复制到Tomcat的webapps目录下，并改名为：helloword
7). 在浏览器的地址栏中输入：http://localhost:8080/helloworld/hello.jsp即可看到命令行的打印信息
8). 配置任意目录下的web应用程序：
在conf目录下依次创建catalina\localhost目录，然后在localhost目录下为test这个web应用程序建立test.xml文件，编辑这个文件输入以下内容
<context
docBase = “E:\\Java\\source\\atguigu\\java-1\\firstwebapp\\webcontent”
reloadable = “true”/>
1. 使用JavaEE版的Eclipse开发动态的WEB工程（JavaWEB项目）
1). 把开发选项切换到JavaEE
2). 可以在Window->Show View 中找到Package Explorer，并把其拖拽到开发区的左边
3). 在Servers面板中新建Tomcat服务器，一定要关联到Tomcat安装的根目录
4). 新建一个Dynamic Web Project。其中Target Runtime 需选择Tomcat6.0
5). 开发JavaWeb应用
6).可以通过run on server来运行WEB项目
2. servlet的HelloWorld
1). 创建一个Servlet接口的实现类
Public class HelloServlet implements Servlet
5 JavaWeb_Servlet的配置及生命周期方法
2). 在web.xml文件中配置和映射这个Servlet
<!-- 配置和映射servlet -->
<servlet>
<!-- Servlet注册的名字 -->
<servlet-name> HelloServlet </servlet-name>
<!-- Servlet的全类名 -->
<servlet-class>com.centfor.test.HelloServlet</servlet-class>
<servlet-mapping>
<!-- 需要和某一个Servlet节点servlet-name子节点的节点文本一致 -->
<servlet-name> HelloServlet </servlet-name>
<!-- 映射具体的访问路径：/代表当前Web应用的根目录 -->
<url-pattern>/Hello</url-pattern>
</servlet-mapping>
</servlet>
3. Servlet容器：运行Servlet、JSP、Filter等的软件环境
1). 可以来创建Servlet，并调用Servlet的相关生命周期方法
2). JSP、Filter、Listener、Tag……
4. Servlet生命周期的方法：以下方法都由Servlet容器负责调用
1). 构造器：只被调用一次，只有第一次请求Servlet时，创建Servlet的实例
这说明Servlet是单实例的！
2). Init方法：只被调用一次，在创建好实例后立即被调用，用于初始化当前Servlet。
3). Service：被多次调用，每次请求都会调用service方法，实际用于响应请求的
4). Destroy： 只被调用一次，在当前Servlet所在的Web应用被卸载前调用，用于释放当前Servlet所占的资源
5. load-on-startup参数：
1). 配置在Servlet节点中：
<!-- 配置和映射servlet -->
<servlet>
<!-- Servlet注册的名字 -->
<servlet-name> HelloServlet </servlet-name>
<!-- Servlet的全类名 -->
<servlet-class>com.centfor.test.HelloServlet</servlet-class>
<!-- 可以指定Servlet被创建的时机 -->
<load-on-startup>-1</load-on-startup>
</servlet>
2). Load-on-startup:可以指定Servlet被创建的时机，若为负数，则在第一次请求时被创建。若为0或正数，则在当前Web应用被Servlet容器加载时创建实例，且数值越小越早被创建。
6. 关于Servlet-mapping：
1). 同一个Servlet可以被映射到多个URL上，即多个 <servlet-mapping> 元素的 <servlet-name>子元素的设置值可以是同一个Servlet的注册名。
2). 在Servlet映射到的URL中也可以使用 * 通配符，但是只能有两种固定的格式：一种格式是“*.扩展名”，另一种格式是以正斜杠(/)开头“/*”结尾。
<servlet-mapping>
<servlet-name>secondServlet</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
OR
<servlet-mapping>
<servlet-name>secondServlet</servlet-name>
<url-pattern>*.do</url-pattern>
</servlet-mapping>
注意：以下的既有/又有扩展名的不合法
<servlet-mapping>
<servlet-name>secondServlet</servlet-name>
<url-pattern>/*.action</url-pattern>
</servlet-mapping>
7. ServletConfig：封装了Servlet的配置信息，并且可以获取ServletContext对象
1). 配置Servlet
<!-- 配置和映射servlet -->
<servlet>
<!-- Servlet注册的名字 -->
<servlet-name> HelloServlet </servlet-name>
<!-- Servlet的全类名 -->
<servlet-class>com.centfor.test.HelloServlet</servlet-class>
<!-- 配置Servlet的初始化参数，且节点必须在load-on-startup节点的前边-->
<init-param>
<!-- 参数名 -->
<param-name>user</param-name>
<!-- 参数值 -->
<param-value>root</param-value>
</init-param>
<init-param>
<param-name>password</param-name>
<param-value>123456</param-value>
</init-param>
<!-- 可以指定Servlet被创建的时机 -->
<load-on-startup>-1</load-on-startup>
</servlet>
2). 获取初始化参数：
> getinitparameter(String name)：获取指定参数的初始化参数
> getinitParameterNames()：获取参数名组成的Enumeration对象
String user = servletConfig.getInitParameter("user");
System.out.println("user:" + user);
Enumeration<String> names = servletConfig.getInitParameterNames();
while(names.hasMoreElements()){
String name = names.nextElement();
String value = servletConfig.getInitParameter(name);
System.out.println("^^" + name + ":" + value);
}
3).获取Servlet的配置名称（了解）
String servletName = servletConfig.getServletName();
System.out.println(servletName);
8. ServletContext
1）. 可以由ServletConfig获取
ServletContext servletContext = servletConfig.getServletContext();
2）. 该对象代表当前Web应用：可以认为ServletContext是当前Web应用的一个大管家，可以从中获取到当前Web应用的各个方面的信息。
① 获取当前Web应用的初始化参数:可以为所有的servlet所获取，而servlet的初始化参数只有那个servlet可以获取
设置初始化参数：
<!-- 配置当前Web应用的初始化参数 -->
<context-param>
<param-name>driver</param-name>
<param-value>com.mysql.jdbc.Driver</param-value>
</context-param>
方法：
GetinitParameter
GetinitParameterNames
代码：
//获取ServletContext对象
ServletContext servletContext = servletConfig.getServletContext();
String driver = servletContext.getInitParameter("driver");
System.out.println("driver:" + driver);
Enumeration<String> names2 = servletContext.getInitParameterNames();
while(names2.hasMoreElements()){
String name = names2.nextElement();
String value = servletContext.getInitParameter(name);
System.out.println("^^" + name + ":" + value);
}
② 获取当前Web应用的某一个文件在服务器上的绝对路径，而不是部署前的路径
GetRealPath(String path);
代码：
String realPath = servletContext.getRealPath("/note.txt");
//不是：F:\MyEclipse 10\day_0509\note.txt
System.out.println(realPath);
③ 获取当前Web应用的名称：
GetContextPath();
代码：
String contextPath = servletContext.getContextPath();
System.out.println(contextPath);
④ 获取当前Web应用的某一个文件对应的输入流
GetResourceAsStream(String path):path的/ 为当前Web应用的根目录
代码：
InputStream
is2 = servletContext.getResourceAsStream("/WEB-INF/classes/jdbc.properties");
⑤ 和attribute相关的几个方法：
9.GET请求和POST请求
1). 使用GET方式传递参数：
① 在浏览器地址栏中输入某个URL地址或单击网页上的一个超链接时，浏览器发出的HTTP请求消息的请求方式为GET。
② 如果网页中的<form>表单元素的method属性被设置为了“GET”，浏览器提交这个FORM表单时生成的HTTP请求消息的请求方式也为GET。
③ 使用GET请求方式给WEB服务器传递参数的格式：
http://www.lamp brother.net/counter.jsp?name=lc&password=123
④ 使用GET方式传送的数据量一般限制在1KB以下。
2). 使用POST方式传递参数：
① POST请求方式主要用于向WEB服务器端程序提交FORM表单中的数据。
② POST方式将各个表单字段元素及其数据作为HTTP消息的实体内容发送给WEB服务器，传送的数据量要比使用GET方式传送的数据量大得多。
POST /counter.jsp HTTP/1.1
Referer: http://localhost:8080/Register.html
Content-type: application/x-www-form-urlencoded
Host:localhost:43
Name=zhangsan&password=123 --请求体中传递参数
10.如何在Servlet中获取请求信息：
1). Servlet的service() 方法用于应答请求：因为每次请求都会调用service()方法
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException
ServletRequest：封装了请求信息，可以从中获取到任何的请求信息。
ServletResponse：封装了响应信息，如果想给用户什么响应，具体可以使用该接口的方法实现。
这两个接口的实现类都是服务器给予实现的，并在服务器调用service()方法时传入
2). ServletRequest：
① 获取请求参数：
String getParameter(String name)：根据请求参数的名字，返回参数
若请求参数有多个值（例如checkbox），该方法只能读取到第一个提交的值
String[] getParameterValues(String name) ：根据请求参数的名字，返回请求参数对应的字符串数组
Enumeration<String> getParameterNames()：返回参数名对应的Enumeration对象，类似于ServletConfg（或ServletContext）的getinitParameterNames()方法
Map<String,String[]> getParameterMap():返回请求参数的键值对 key：参数名 value：参数值，String数组类型
② 获取请求的URL：
HttpServletRequest httpServletRequest = (HttpServletRequest)request;
String requestURL = httpServletRequest.getRequestURL();
System.out.println(requestURL);
③ 获取请求方式：
String method = httpServletRequest.getMethod();
System.out.println(method); //GET
④ 若是一个GET请求，获取请求参数对应的那个字符串，即 ？ 后的那个字符串
String queryString = httpServletRequest.getQueryString();
System.out.println(queryString);
//user=atguigu&password=123456&interesting=party&interesting=shopping&interesting=game/loginServlet
⑤ 获取请求的Servlet的映射路径
String servletPath = httpServletRequest.getservletPath();
System.out.println(servletPath); //loginservlet
⑥ 和attribute相关的几个方法
3). HttpServletRequest:是ServletRequest的子接口。针对于HTTP请求所定义，里边包含了大量获取Http的信息
4). ServletResponse：封装了响应信息，如果想给用户什么响应，具体可以使用该接口的方法实现。
① *getWriter(): 返回PrintWriter对象，调用该对象的print()方法，将把print()中的参数直接打印到客户的浏览器上
② 设置响应的内容类型：response.setConfigType(“application/msword”);
③ void sendRedirect(String location):请求的重定向（此方法为HttpServletResponse中定义）
---------------------------------习题------------------------------------
在web.xml文件中设置两个WEB应用的初始化参数，user，password。
定义一个login.html，里边定义两个请求字段：user，password
再创建一个LoginServlet，在其中获取请求的user，password。比对其和web.xml文件中定义的请求参数是否一致
若一致，响应Hello：xxx，若不一致，响应Sorry：xxx 其中xxx为user
1.GenericServlet（了解）
1). 是一个Servlet。是Servlet接口和ServletConfig接口的实现类，但是一个抽象类，其中的service方法为抽象方法
2). 如果新建的Servlet程序直接继承GenericServlet会使开发更简洁些。
3). 具体实现：
① 在GenericServlet中声明了一个ServletConfig类型的成员变量，在Init(ServletConfig)方法中对其进行了初始化
② 利用ServletConfig成员变量的方法实现了ServletConfig接口的方法
③ 还定义了一个init()方法，在init(ServletConfig)方法中对其进行调用，子类可以直接覆盖Init()，在其中实现对Servlet的初始化
④ 不建议直接覆盖init(ServletConfig)，因为如果忘记编写super.init(config);而还是利用了ServletConfig接口的方法，则会出现空指针异常
⑤ 新建的init(){}并非Servlet的生命周期方法，而init(ServletConfig)是生命周期相关的方法
2.HttpServlet
1). 是一个Servlet，继承自GenericServlet，针对于Http协议所定制
2). 在service() 中直接把ServletRequest和ServletResponse转为HttpServletRequest和HttpServletResponse，并调用了重载的service(HttpServletRequest, HttpServletResponse)
在service(HttpServletRequest, HttpServletResponse)获取请求方式：request.getMethod().根据请求方式又创建了doXxx()方法（xxx为具体的请求方式，如doGet，doPost）
3). 实际开发中，直接继承HttpServlet，并根据请求方式复写doXxx()方法（主要指doGet或doPost）
4).好处：直接由针对性的覆盖doXxx()方法；直接使用HttpServletRequest和HttpServletResponse，不再需要强转
3.
-------------------------------------习题-----------------
在MySql数据库中创建一个test_users数据表，添加3个字段：id,user,password,并录入几条记录
定义一个login.html,里边定义两个请求字段：user，password 发送请求道loginServlet
再创建一个LoginServlet（需要继承自HttpServlet，并重写其doPost方法）
在其中获取请求的user，password
利用JDBC从test_users中查询有没有和页面输入的user，password对应的记录
Select count(id) from test_user where user = ? and password = ?
若有，响应Hello：xxx，若没有，响应Sorry：xxx 其中xxx为user
4 请求的转发和重定向：
1). 本质区别： 请求的转发只发出了一次请求，而重定向则发出了两次请求
具体：
① 请求的转发：地址栏是初次发出请求的地址
请求的重定向：地址栏不再是初次发出的请求地址。地址栏为最后响应的那个地址。
② 请求转发：在最终的Servlet中，request对象和中转的那个request是同一个对象
请求的重定向：在最终的Servlet中，request对象和中转的那个request不是同一个对象
5. JSP
1). WHY：
JSP是简化Servlet编写的一种技术，它将Java代码和HTML语句混合在同一个文件中编写，只对网页中的要动态产生的内容采用Java代码来编写，而对固定不变的静态内容采用普通静态HTML页面的方式编写。
2). Java Server Page:Java服务器端网页，在HTML页面中编写Java代码的页面
2). Helloworld:
新建一个JSP页面，在body节点内的<% %>即可编写Java代码
<body>
<%
Date date = new Date();
Syetem.out.print(date);
%>
</body>
3). JSP可以放置在WEB应用程序中的除了WEB-INF及其子目录外的其他任何目录中，JSP页面的访问路径与普通HTML页面的访问路径形式也完全一样。
4). JSP的运行原理：
每个JSP 页面在第一次被访问时，JSP引擎将它翻译成一个Servlet源程序，接着再把这个Servlet源程序编译成Servlet的class类文件，然后再由WEB容器（Servlet引擎）像调用普通Servlet程序一样的方式来装载和解释执行这个由JSP页面翻译成的Servlet程序
5). JSP页面的隐含变量：没有声明就可以使用的对象，JSP页面一共有9个隐含对象
Public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response) {
throws java.io.IOException, javax.servlet.ServletException
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
//……………………..
//使用<% %>编写的代码在此位置，可以用到request，response，pagecontext，session，
//application,config,out,page这8个隐含对象。（实际上还可以使用一个叫exception的隐含对象）
}
① request：HttpServletRequest 的一个对象
② response：HttpServletResponse 的一个对象（在JSP页面中几乎不会调用任何response的方法）
③ pageContext：页面的上下文，是PageContext的一个对象，可以从该对象中获取到其他8个隐含对象。也可以从中获取到当前页面的其他信息。（学习自定义标签时使用它）
④ session：代表浏览器和服务器的一次会话，是HttpSession的一个对象。后面详细学习。
⑤ application：代表当前WEB应用。是ServletContext对象。
⑥ config：当前JSP对应的Servlet的ServletConfig对象（几乎不使用）。若需要访问当前JSP配置的初始化参数，需要通过映射的地址才可以。
映射JSP：
<servlet>
<servlet-name>hellojsp</servlet-name>
<jsp-file>/Hello.jsp</jsp-file>
<init-param>
<param-name>test</param-name>
<param-value>123456789</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>hellojsp</servlet-name>
<url-pattern>/hellojsp</url-pattern>
</servlet-mapping>
⑦ out：JspWriter对象。调用out.println()可以直接把字符串打印在浏览器上。
⑧ page：指向当前JSP对应的Servlet对象的引用，但为Object类型，只能调用Object类的方法（很少使用）
⑨ exception：在声明了page指令的isErrorPage=true”时，才可以使用
<%@ page isErrorPage = "true" %>
pageContext,request,session,application（对属性的作用域的范围从小到大）
out,response,config,page
exception
6). JSP模版元素：JSP页面中的静态HTML内容
7). JSP表达式（expression）提供了将一个java变量或表达式的计算结果输出到客户端的简化方式，它将要输出变量或表达式直接封装在<%= 和%>之中。
<%
Date date = new Date();
Out.print(date);
%>
<%= date %>
8).JSP脚本片段(scriptlet)是指嵌套在<%和%>之中的一条或多条Java代码程序
多个脚本片段中的代码可以相互访问
<%
String ageStr = request.getParameter("age");
Integer age = Integer.parseInt(ageStr);
if(age >= 18){
%>
成年人....
<%
}else if(age < 18){
%>
未成年人...
<%
}
%>
1. JSP指令：是为JSP引擎而设计的，它们并不直接产生任何可见输出，而只是告诉引擎如何处理JSP页面中的其余部分
2. 在目前的JSP2.0中，定义了page、include和taglib这三种指令
3.page指令
1). Page指令用于定义JSP页面的各种属性，无论page指令出现在JSP页面中的什么地方，它作用的都是整个JSP页面，为了保持程序的可读性和遵循良好的编程习惯，page指令最好是放在整个JSP页面的起始位置
2). Page指令常用的属性：
① import属性：指定当前JSP页面对应的Servlet需要导入的类
<%@ page import = “java.text.DateFormat” %>
② session属性：取值为true或false，指定当前页面的session隐藏变量是否可用，也可以说访问当前页面时是否一定要生成HttpSession对象
<%@ page session = “false” %>
③ errorPage 和isErrorPage：
<%@ page errorPage = “/error.jsp” %>
<error-page>
<!-- 指定出错的代码：404 没有指定的资源 500内部错误 -->
<error-code>404</error-code>
<!-- 指定响应页面的位置 -->
<location>/WEB-INF/error.jsp</location>
</error-page>
<error-page>
<!-- 指定异常的类型 -->
<exception-type>java.lang.ArithmeticException</exception-type>
<location>/WEB-INF/error.jsp</location>
</error-page>
④ contenttype：指定当前JSP页面的响应类型，实际调用的是response.setContentType("text/html; charset= UTF-8");通常情况下，对于JSP页面而言其取值均为text/html；charset=UTF-8.charset指定返回的页面的字符编码是什么。通常取值为UTF-8.
⑤ pageEncoding：指定当前JSP页面的字符编码，通常情况下该值和contentType中的charset一致
⑥ isELIgnored:指定当前JSP页面是否可以使用EL表达式，通常取值为true。
无笔记
标签：
原文地址：http://www.cnblogs.com/hnini/p/5334359.html
