Normal
(普通)
Servlet学习笔记
Version 1.0
2010.06
All Rights Reserved
目录
1 第一章tomcat介绍 (4)
1.1 介绍 (4)
2 第二章Http请求介绍(get、post请求) (4)
2.1 Get请求 (4)
2.2 Post请求 (4)
2.3 Get、Post的区别 (5)
3 第三章什么是Servlet (6)
3.1 服务器端组件技术 (6)
3.2 Servlet介绍 (6)
3.3 web项目及基本结构 (6)
3.4 web服务器介绍(servlet容器)及配置 (6)
3.5 servlet的生命周期 (7)
4. 第四章创建一个Servlet程序 (8)
4.1如何创建 (8)
4.2 servlet例子 (10)
5 第五章servlet实现类、方法介绍 (12)
5.1 GenericServlet类介绍 (12)
5.2 ServletConfig对象(web.xml配置信息) (12)
5.3 HttpServlet类介绍 (12)
5.4 获取请求参数方法 (13)
5.5 httpServlet请求、响应编码问题 (14)
5.6 获得Web路径问题URI、URL (15)
6 第六章转发、重定向、servletContext介绍 (16)
6.1 重定向介绍 (16)
6.2 重定向原理及使用 (16)
6.3 转发原理及使用 (18)
6.4 转发、重定向的区别 (19)
6.5 绝对路径、相对路径 (19)
6.6 servletContext对象 (20)
7 第七章Cookie 、Session的使用 (20)
7.1 Cookie的使用 (20)
7.2 Session的使用 (22)
8 第八章Filter、wrapper、Listener的介绍及使用 (24)
8.1 Filter过滤器的介绍及使用 (24)
8.2 wrapper代理模式的使用 (26)
8.3 Listener监听器的使用 (27)
1第一章tomcat介绍
1.1 介绍
Tomcat服务器是在sun公司JSWDK(是sun公司推出的小型servlet/jsp调试工具)的基础上发展起来的优秀servlet/jsp容器。它是Apache-Jakarta软件组织的一个子项目。它不但支持运行servlet/jsp，而且还具备了作为商业JavaWeb应用服务特征。是个开源软件，用Java写的。
2第二章Http请求介绍(get、post请求)
Http请求有三部分组成：
1.请求方法URI协议/版本
2.请求头(Request Header)
3.请求正文
Http请求可以分成多种，如HTTP/1.1支持7种请求方式：GET、POST、HEAD、OPTIONS、PUT、DELETE、TRACE。
在网络上最为常用的是：GET、POST
2.1Get请求
GET /simple.jsp HTTP/1.1 ---GET表示请求方式、/simple.jsp表示URI、HTTP/1.1表示协议、版本
Host: localhost:8080 ---表示你要访问的地址
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)
Gecko/20050225 Firefox/1.0.1
Connection: Keep-Alive
2.2Post请求
POST /simple.jsp HTTP/1.1 ---POST请求
Host: localhost:8080
User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.6)
Gecko/20050225 Firefox/1.0.1
Content-Type: application/x-www-form-urlencoded
Content-Length: 40 ---表示请求数据长度，post请求有数据，get请求没有
Connection: Keep-Alive
（----此处空一行----）
name=aaa &possword=123 ---这就是post请求出去的信息，也是明码显示的(不安全) 与get比较只是显示的
地方不同
Http的响应
HTTP/1.1 200 OK
--- 200 (OK): 表示找到了该资源，并且一切正常
--- 304 (NOT MODIFIED): 该资源在上次请求之后没有任何修改。这通常用于浏览器的缓存机制。
--- 401 (UNAUTHORIZED): 客户端无权访问该资源。这通常会使得浏览器要求用户输入用户名和密码，以登录到服务器。
--- 403 (FORBIDDEN): 客户端未能获得授权。这通常是在401之后输入了不正确的用户名或密码。
--- 404 (NOT FOUND): 在指定的位置不存在所申请的资源。
Server: ApacheTomcat/5.0.12 --- 这里开始 协议头文件
Date: Sat, 31 Dec 2005 23:59:59 GMT
Content-Type: text/html;charset=ISO-8859-1 --- 表示响应数据的格式(text/html、text/css)，即告诉IE 是什么类型的文件。若类型IE不认识，就不能显示，会下载下来 Last-Modified: 写时间 --- 表示响应的文件什么时候更新过
Content-Length: 122 --- 文件大小(响应数据的长度)
--- 这里协议头结束
--- 响应正文开始
Get是先要了页面信息，当页面中有时，就get css文件，若还有js文件就get js文件。
304 Not Modified --- 表示向服务器get请求时，如请求css文件，但本地的IE缓存文件夹中已经有了这个文件，而且是没有修改过的(和上次请求一样的文件)，Server就不发送这个信息了
2.3Get、Post的区别
Get的提交: 在地址栏上输入 www.localhost:8080/test.do?name=aaa&password=123
查询字符串的长度受到web浏览器和web服务器的限制（如IE最多支持2048个字符，大小<2K），不适合传输大型数据集，不能上传非文本的数据。
Post的提交: post是以表单形式的提交，name\password是看不到的
请求参数是在http标题的一个不同部分（名为entity body）传输的，这一部分用来传输表单信
息，因此必须将Content-type设置为:application/x-www-form-urlencoded。
post设计用来支持web窗体上的用户字段，其参数也是作为key/value对传输。
主要区别:
1.安全性 都不安全，Get更不安全。
2.get请求参数大小 < 2k，不能上传非文本的数据。
3.post提交的文件可以大，可以上传文本和非文本的格式，理论上文件大小无限制，但服务器会给加上文
件的限制大小的上限，不然内存不够。
总结:
现在有CS结构、BS结构
CS --- Client-Server 如网络游戏就需要客户端、服务器端。客户端需要不断的更新。操作麻烦。
BS --- 浏览器-Server 等于规定了标准的Clinet(浏览器)和标准的通信协议(Http)，只需要更新服务器即 可。 是目前流行的趋势。
RIA技术 --- 富客户端技术。相当于 CS与BS之间。即浏览器运行大量的js脚本语言，使网页更丰富。 如：ExtJS 技术
3 第三章 什么是Servlet
3.1 服务器端组件技术
CGI、PHP、Servlet/Jsp、ASP
3.2 Servlet 介绍
Servlet 是与平台无关的服务器端组件，是按SUN 公司的Servlet 标准写的Java 类。Servlet 可以在实现了SUN
公司的Servlet 标准容器(tomcat 容器、weblogic 容器 等，提供了支持运行Servlet 的一些底层封装)中运行。
Servlet 容器负责Servlet 和客户通信以及调用Servlet 的方法，Servlet 和客户的通信采用“请求响应”模式。
Servlet 可以在容器的支持下处理HTTP 请求和响应，动态生成HTML。
3.3 web 项目及基本结构
① 一个web 项目中可以有多个 servlet，结构由SUN 公司规定的。(手工创建一个web 工程)
1. 文件夹创建，命名为myApp。
2. 在myApp 文件夹下再建 WEB-INF 文件夹。在WEB-INF 下再建classes、lib 文件夹及web.xml 文件。
3. 在myApp 下与WEB-INF 同目录中建一个index.html 文件。
4. 把这个myApp 文件夹放到Tomcat 下的webapps 文件中。
② 普通的web 应用结构图 (WEB-INF 目录在网络上是不可见的)
3.4 web 服务器介绍(servlet 容器)及配置 Servlet 运行在web 容器中，web 容器可以控制servlet 对象生命周期，控制请求由servlet 对象处理。容器和
servlet 的接口由 Java Servlet API 定义的，servlet 在生命周期中会被web 容器调用。Servlet API 还定义了容
器创建并传给servlet 的对象类，如 ServletRequest 对象、ServletResponse 对象。
ServletRequest 对象 --- 封装了客户请求的信息，由容器创建
ServletResponse 对象 --- servlet 把响应结果写到servletResponse
中，传递给客户
Web服务器有 Tomcat、Jboss、Weblogic等。Tomcat是开源的，用Java语言编写，所以需要相应的Java运行环境，也就是JVM，需要配置Tomcat的环境变量。(myEclipse配置的Tomcat不需要配置环境变量) Tomcat配置: unix下的
JAVA_HOME = /opt/jdk1.6.0 (JDK路径，bin的上一层目录，即java的根目录)
CATALINA_HOME = /home/soft01/tomcat (tomcat根目录)
Export CATALINA_HOME JAVA_HOME
Chmod u+x *.sh --- 给sh文件加上可执行权限
Tomcat 启动: catalina.sh run (catalina.bat run --- windows下)
MyEclipse配置: window--preference--MyEclipse--Application servers--Tomcat ...
3.5 servlet的生命周期
Servlet的生命周期可以分为四个阶段，即装载类及创建实例阶段、初始化阶段、服务阶段、实例销毁阶段。
1.装载类及创建实例阶段(客户第一次请求时实例化servlet对象,也可以通过配置启动tomcat时实例化)
客户端向Web服务器发送一个请求，请求的协议及路径必须遵守如下的格式：
http://serverip:port/application-path/resource-path
serverip --- Web服务器的IP地址, port ---为服务器的端口号,tomcat默认为8080
application-path ---服务器中发布的某个应用的路径，若为缺省应用(比如tomcat的ROOT),可以为空。
resource-path ---客户端要访问的服务器中的资源的路径。
如:http://127.0.0.1:8090/gzwjs/index.jsp
创建实例
在默认时Servlet实例是在第一个请求到来的时候创建，以后复用。如果有的Servlet需要复杂的操作需要载初始化时完成(比如打开文件、初始化网络连接等),可以通知服务器在启动时创建该Servlet
的实例。具体配置如下：web.xml
其中
负数或无：表示由容器来决定装载的时机，通常为第一个请求该servlet的时候装载。
2. 初始化阶段(实例化后自动调用init方法,只调用一次)
一旦Servlet实例被创建，容器会自动调用init(ServletConfig config)方法来初始化Servlet。其中方法参数config中包含了Servlet的配置信息，比如初始化参数，该对象由容器创建。配置: web.xml Servlet 的public void init(ServletConfig config) throws ServletException{}方法
配置初始化参数 user ,值为 helloworld(有点像map中的key、vale)
①如何获取初始化参数?
ServletConfig接口中有个public String getInitParameter(String name)方法,使用:
String value = config.getInitParameter("user");
--- value 为 "helloworld", 若参数值没有配置则返回null
public Enumeration getInitParameterNames() --- 返回配置的所有初始化参数名称的枚举类型
② init(ServletConfig config)方法
init(ServletConfig config) 只调用一次,该方法执行在单线程的环境下，因此不用考虑线程安全的问题。
该方法会抛出ServletException异常,容器就不会将客户端请求交给Servlet实例来处理，而是报告初始化失败异常信息给客户端，该Servlet实例将被从内存中销毁。如果再来新的请求，容器会创建新的Servlet实例，并执行新实例的初始化操作。
③ init(ServletConfig config)方法的覆盖\重写问题
GenericServlet类中实现了该方法
public void init(ServletConfig config) throws ServletException{
this.config = config; //属性变量config
init();
}
子类只需重写init() 方法即可,如果一定要重写init(ServletConfig config)方法建议包含一句super.init(config)
3. 服务阶段(收到一次客户请求就会调用一次service()方法,只要发一个请求就调用一次)
一旦Servlet实例创建及初始化后，该Servlet实例就可以接收客户端的请求并生成响应。在服务阶段容器会调用该实例的service(ServletRequest request, ServletResponse response)方法，request对象和response对象由容器创建并传给Servlet实例。
①service(ServletRequest request, ServletResponse response)使用:
service()方法为Servlet的核心方法，客户端的业务逻辑应该在该方法内执行。为了提高效率，Servlet规范要求一个Servlet实例必须能够同时服务于多个客户端请求，即service()方法运行在多线程的环境下，Servlet开发者必须保证该方法的线程安全性。
4. 实例销毁阶段(销毁该对象前调用destroy()方法)
容器必须保证调用destroy()方法之前，让所有正在运行在该实例的service()方法中的线程退出。一旦destroy()方法已经执行，容器将拒绝所有的新来的对该Servlet实例的请求，destroy()方法退出，该Servlet实例即可以被垃圾回收。
4. 第四章创建一个Servlet程序
4.1如何创建
1.用MyEclipse 选 web Project 建工程名 xxx, 点完成
2.web.xml文件配置
xmlns="https://www.doczj.com/doc/ba13511652.html,/xml/ns/j2ee" xmlns:xsi="https://www.doczj.com/doc/ba13511652.html,/2001/XMLSchema-instance" xsi:schemaLocation="https://www.doczj.com/doc/ba13511652.html,/xml/ns/j2ee https://www.doczj.com/doc/ba13511652.html,/xml/ns/j2ee/web-app_2_4.xsd">
假设:本工程为 myServlet,
访问http://127.0.0.1:8090/myServlet --- 显示 index.jsp页面的内容(欢迎页面)
访问http://127.0.0.1:8090/myServlet/one --- 就是访问TestServlet类
3.一个servlet实体类
实现servlet接口要重写5个方法,见下面:
public class TestServlet implements Servlet {
public void destroy() {}
public ServletConfig getServletConfig() { r eturn null;}
public String getServletInfo() { return null;}
public void init(ServletConfig servletconfig) throws ServletException {}
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException {
response.getWriter().write("hello");
}
}
注: 配置
这样只能在web应用下访问,如 http://127.0.0.1:8090/myServlet/one ---正确
http://127.0.0.1:8090/myServlet/hello/one ---不能访问配置
这样任何地方都可以访问,如http://127.0.0.1:8090/myServlet/test.do --- 可以访问
http://127.0.0.1:8090/myServlet/hello/test.do --- 可以访问说明设置了*.do,可以不用担心目录问题,可以不用只在web应用下访问,但必须在这个web应用目录范围内ServletRequest、ServletResponse是2个接口(由sun定义的),tomcat提供了对这2个接口的实现,会在调用service方法的时候传递这2个对象,tomcat实现了这2个接口中的所有方法。
ServletRequest: 封装了请求的信息; ServletResponse: 封装了响应的信息
注: 编写servlet必须要实现servlet接口,程序没有main()方法。当修改了类的内容,需要重新部署。
访问方式: http://127.0.0.1:8080/myServlet/one
①当访问的时候,当接收到一个连接请求,就会为其分配一个线程。
② tomcat的web应用(文件夹)放在webapps目录下。每个web应用下都要有WEB-INF文件夹, WEB-INF
文件夹下有classes、lib文件夹以及web.xml文件
③ tomcat中配置了root缺省应用,也就是在不指定web应用的情况下会默认访问这个web应用。如:
http://127.0.0.1:8080/ 就可以访问在root目录下的工程
④访问应用时,在端口号后加上web应用名。
注: 静态页面只能放在web应用的文件夹下,不能放在WEB-INF文件夹下, WEB-INF文件夹下的资源是受保护的,不能通过网络访问,但可以通过转发访问,具体见转发介绍。
4.2 servlet例子
1.读取一个html文件
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException {
FileInputStream in = new FileInputStream(...); --- 本机上找一个html文件
BufferedReader br = new BufferedReader(new InputStreamReader(in));
response.setContentType("text/html"); --- 相当于设置响应信息中的content-Type
的类型(见Http响应)
PrintWriter out = response.getWriter(); --- 用out输出的数据就相当于响应,输出的
数据就是响应后后面的数据,其实也就是写到浏览器上While(true){
String temp = br.readLine();
if(temp == null) break;
out.println(temp);
}
}
2.从DB中查出数据到浏览器
public void service(ServletRequest request,ServletResponse response) throws
ServletException,IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
Connection con = DBTool.getConnection();
String sql = "select * from emp";
PreparedStatement ps = con.prepareStatement(sql);
ResultSet rs = ps.executeQuery();
out.println("");
out.println("
out.println("
| ID | Name |
| "+ id +" | ");"+ name +" | ");
out.println("");
}
3.表单数据提交
Html的form表单,页面放到web应用目录下(WebRoot下)
这个form表单提交访问的是/two 的servlet。
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException {
request.setCharacterEncoding("utf-8"); --- 设置编码(后面有详细介绍)
String name = request.getParameter("name");
--- 获取表单元素对应的值
String pwd = request.getParameter("pwd");
response.getWriter().write("name="+ name +"-- pwd="+ pwd);
}
注:现在有个问题是2个servlet怎么在web.xml中配置?
5 第五章servlet实现类、方法介绍
5.1 GenericServlet类介绍
GenericServlet与servlet关系:
GenericServlet是实现了servlet接口中除了service()方法以外的其他4个方法(简单实现)。
在GenericServlet中多了以下属性,方法:
private transient ServletConfig config;
public void init(ServletConfig config) throws ServletException{
this.config = config; //属性变量config
init();
}
public void init() throws ServletException{ }
一般我们只需要重写init()方法即可,如果要重写init(config)方法,应先调用super.init(config)确保参数引用ServletConfig对象。
在无参的init()方法中若使用ServletConfig对象,可以调用getServletConfig()方法获取对象。
init方法主要完成一些初始化工作,如建立数据库连接、获取配置文件。
5.2 ServletConfig对象(web.xml配置信息)
ServletConfig对象--- 在servlet初始化时,向其传递配置信息。由容器来传递的。
Tomcat对ServletConfig对象提供了实现。
ServletConfig对象封装了对servlet的配置信息(web.xml配置),并在初始化的时(调用init方法)将配置信息传递给servlet。ServletConfig对象放在属性域中(数据成员)。
关于ServletConfig对象在web.xml配置,见P.6.页(servlet生命周期)有介绍。
例: ServletConfig对象的获取
public void service(ServletRequest request,ServletResponse response) throws ServletException,IOException {
ServletConfig config = this.getServletConfig(); //获取ServletConfig对象
String name = config.getInitParameter("user");
System.out.println(name); --- 显示helloworld
}
5.3 HttpServlet类介绍
HttpServlet是GenericServlet的子类。HttpServlet重写了service方法,这个方法根据请求的不同来分别去调用自己的doGet或doPost方法。
注: 在浏览器的地址栏操作或热连接,都是get请求。在form的method属性若不指定,默认也是get请求。
1.HttpServlet类方法的使用
public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException{
①Enumeration h = req.getHeaderNames();
--- 返回本次请求中包含的所有报头名字的枚举集合
while(h.hasMoreElements()){
String head = (String)h.nextElement(); --- Iterator的next()一样
String value = req.getHeader(head); --- 返回请求的头信息,这里为head的请求报
头的值,若无指定报头就返回null
}
② String clientIP = req.getRemoteAddr();
--- 获取访问这个服务器的那个电脑(客户端)的IP地址
③String method = req.getMethod();--- 返回是get还是post请求,即判断请求类型
④res.setContentType("text/html;charset=utf-8") --- 响应客户端的编码格式
⑤InputStream in = req.getInputStream(); --- 获取请求的字节流
⑥PrintWriter out = resp.getWriter(); --- 获取响应输出流,输出流中有一个缓存区
} (具体见转发)
public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException, ServletException{
}
5.4 获取请求参数方法
http://127.0.0.1:8080/myServlet/one?id=123 (get方法传递)
1.在地址的基础上增加一些额外的请求信息,这些信息可以被服务器端组件获取,可以用:
request.getParameter("id")来获取值
注:在地址栏不写请求参数id,则getParameter("id")为null;在地址栏写了one?id= ,则getParameter("id")返回""(空)。
2.表单若用get提交,就是通过请求参数传递信息
例: 当前请求为 http://127.0.0.1:8080/myServlet/one?id=123&name=aaa&name=bbb&name=ccc (注:这里有3个请求参数name)
String id = request.getParameter("id");
String name = request.getParameter("name"); ---这个方法只能得到第一个name的值,即aaa 怎么得到全部name的值呢？
①返回数组形式
String[] names = request.getParameterValues("name");
---返回一个所有name对应值的数组{aaa,bbb,ccc}
②返回Map形式
Map map = request.getParameterMap();
--- 以Map形式得到id,name的值,Map
for(String s : (Set
String[] temp = (String[])map.get(s);
显示: id --- {"123"}
name --- {"aaa","bbb","ccc"}
}
Iterator it = map.keySet().iterator();
While(it.hasNext()){
String key = (String)it.next();
String[] temp = (String[])map.get(key);
}
③ 获取一个字符串
String args = request.getQueryString();
--- 返回 id=123&name=aaa&name=bbb&name=ccc(字符串),即URL路径后的查询字符串,如果URL后无查询字符串,则返回null
5.5 httpServlet请求、响应编码问题
在上面这个form请求中,账号用了中文字"张三"
public void doPost(HttpServletRequest requese, HttpServletResponse response) throws IOException, ServletException{
为了正确获取这个"张三" ,需要以下设置:
request.setCharacterEncoding("utf-8"); ①
--- 设置表单提交得到的文字(如:汉字)的编码格式。注意:这个方法必须放到所有getParameter()方法的最前面,否则得到的文字("张三")都无法正确显示。Tomcat默认用ISO 8859-1编码。
String name = request.getParameter("name"); --- 现在表单中输入的中文字就转成了
"utf-8"的编码了,而不是像%E6%A5%C8%...这样的格式了。
response.setContentType("text/html;charset=utf-8");
--- 这里是响应的utf-8编码设置,但如果① 语句不设置的话,在表单中输入的中文字还是不能正确显示在新页面上的,由于post得到的编码("张三")已经是乱码了,怎么转换都没用了。
PrintWriter out = response.getWriter();
out.println("
" + name +"");}
编码问题总结:
1.响应页面指定编码
<1> 静态页面html设置:
<2> 动态页面(Servlet来实现)输出设置:
response.setContentType("text/html;charset=utf-8");
2.表单提交编码
<1> post 提交
在获得表单信息前,调用request.setCharacterEncoding("utf-8")指定的编码和表单页面的
编码一致(浏览器会按照表单页面的编码提交中文)。
如: html的静态编码为"utf-8",则setCharacterEncoding("utf-8")要统一。
<2> get 请求
若在地址栏: http://127.0.0.1:8080/myServlet/one?name="张三"(中文输入的) 上面的"张三",在终端会显示??(乱码),无法正确显示出来,对于这样的get请求,可以通过二种方法来正确显示。
① String name = request.getParameter("name"); "GBK"
String str = new String(name.getBytes("ISO-8859-1"),"utf-8");
--- 就是将ISO-8859-1编码的字符串转换成utf-8编码的字符串
②修改tomcat的server.xml文件或在地址栏上name= %E6%A5%C8%... ,这样就可以在
终端正确显示中文了。
Tomcat的server.xml的设置:
maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" acceptCount="100" connectionTimeout="20000" redirectPort="8443" disableUploadTimeout="true" maxPostSize=(post提交的大小,以字节为单位。若不限制文件大小可以写为0 ) URIEncoding="utf-8"(用于get请求时的编码设置) /> 对于上面的"张三"要正确显示,应设置 URIEncoding="GBK",而html中的 content="text/html;charset=GBK" ,这两个同时设置并统一,这样在浏览器上才能 正确显示出来。 5.6 获得Web路径问题URI、URL 1. String uri = request.getRequestURI(); --- 返回在http请求行中,请求URI的一部分。 如: http://127.0.0.1:8080/myServlet/one --- 返回 /myServlet/one Post /some/a.html 返回 /some/a.html Get http://foo.bar/a.html 返回 a.html Head /xy?a=b 返回 /xy 注:返回中包含web应用目录 2. String url = request.getRequestURL(); --- url路径。 如: http://127.0.0.1:8080/myServlet/one?name=aaa 返回为http://127.0.0.1:8080/myServlet/one , 注意:不包括请求参数 3. String path = request.getContextPath(); --- 返回请求URI中表示请求上下文的部分,其实就是返回一个web应用目录。 如: http://127.0.0.1:8080/myServlet/one 返回/myServlet(web应用目录) 4. String realPath = this.getServletContext().getRealPath("..."); --- 返回一个绝对路径,当参数为空时,返回一个到web应用目录的绝对路径(tomcat下的web目录)。 如: getRealPath("") --- 返回/home/soft01/tomcat/webapps/myServlet getRealPath("/temp/a.txt") ---返回/home/soft01/tomcat/webapps/myServlet/temp/a.txt getRealPath("web/a.txt") ---返回/home/soft01/tomcat/webapps/myServlet/web/a.txt 注:可见getRealPath()得到的就是web应用目录的绝对路径,内层目录可以用参数来添加指定,不判断参数中的文件有无。 5. 用getClassLoader()获取绝对路径 ①在web项目中的使用,在servlet中写: ⑴ URL path = this.getClass().getClassLoader().getResource(""); 由main函数运行: D:\workspace\myServlet\WebRoot\WEB-INF\classes\ 通过网络运行: file:/F:/tomcat6.2/webapps/myServlet/WEB-INF/classes/(tomcat路径) 由于".class"文件在classes目录下,而获取路径不指定到包名 ⑵ URL path = this.getClass().getClassLoader().getResource("conf/rule.xml"); --- 指定文件名由main函数运行: D:\workspace\myServlet\WebRoot\WEB-INF\classes\conf/rule.xml 通过网络运行: file:/F:/tomcat6.2/webapps/myServlet/WEB-INF/classes/conf/rule.xml 注: 若rule.xml文件不存在,则返回null (需要判断参数中的文件是否存在) ②在普通Java工程中使用: Foo.class.getClassLoader().getResource("") 显示: /home/soft01/workspace/test --- test为工程名,路径只指定到工程名目录 注: 这里的路径也是对于".class"的位置的 6. String path = request.getServletPath(); --- 获取servlet 路径 如: http://127.0.0.1:8080/myServlet/main/list.jsp ---返回/main/list.jsp 6 第六章转发、重定向、servletContext介绍 6.1 重定向介绍 重定向技术可以分为两类，一类是客户端重定向，另一类是服务器端重定向。客户端重定向可以通过设置特定的HTTP头，或者写JavaScript脚本实现。 1. 客户端重定向用JavaScript实现 --- index.html(在WebRoot下)
当我们访问index.html的时候,通过JS重定向到了desktop.html页面
2. 服务器的重定向(重点)
在Get请求一个页面,如http://127.0.0.1:8080/myServlet/one.do
①GET /one.do HTTP/1.1 --- 请求
Connection : Keep-Alive
②HTTP/1.1 200 OK --- 响应
Server : Apache-Coyote/1.1
③GET /two.do HTTP/1.1 --- 请求
Connection : Keep-Alive
④HTTP/1.1 200 OK --- 响应
... 显示页面了
可见以上进行了2次请求,第一次请求one.do,one把two.do的路径返回给客户端,客户再一次请求two.do显示页面,即第2次请求。(两个不同请求)
6.2 重定向原理及使用
重定向原理图
①当浏览器访问servlet-1
②Servlet-1想让servlet-2为客户端服务,现在只是个构思,servlet-1返回客户端征求意见就是③步了
③Servlet-1调用sendRedirect()方法,将客户端的请求重定向到servlet-2
④这时浏览器就访问servlet-2
⑤Servlet-2对客户端的请求做出响应
要使用重定向必须是继承httpServlet的类,才能使用
例1: 重定向的使用
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
response.sendRedirect("test.html"); --- 重定向到test.html页面
注意: test.html必须放到web应用目录下,不能放到WEB-INF下面}
当http://127.0.0.1:8080/myServlet/one.do请求时,在浏览器上会跳转到
http://127.0.0.1:8080/myServlet/test.html(网址变动可以在浏览器上看的到)注: 重定向要求路径中有web应用目录名,没有web应用目录名,就是相对于当前的servlet路径。
有" / " 就是绝对路径,没有就是相对于当前的servlet路径。见下面例2
重定向可以在浏览器地址栏上看到网址变动
如上面的sendRedirect("test.html")没有任何web应用、" / ",就说明是相对于当前servlet路径例2 :
页面结构图:
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
① response.sendRedirect("jsp/hello.jsp"); --- 重定向到jsp/hello.jsp页面
成功跳转,相对于当前servlet路径,而当前servlet路径就是web应用下面的}
②当response.sendRedirect("/jsp/hello.jsp"); ---路径中前面多了一个" / "
请求http://127.0.0.1:8080/myServlet/one.do时,
地址栏上显示为http://127.0.0.1:8080/jsp/hello.jsp ---显示访问错误
可以看到web工程名都换成了jsp了,说明" / "为绝对路径。
要正确访问可以修改为response.sendRedirect("/test/jsp/hello.jsp") 或
response.sendRedirect(request.getContextPath()+"/jsp/hello.jsp")
6.3 转发原理及使用
转发:用户就发了一次请求,而这个请求在2个servlet中传递,可见requset是共享的。
①浏览器访问servlet-1
② Servlet-1想让servlet-2对Client的请求进行响应,于是调用forward(),将请求转发给
servlet-2处理
③ servlet-2对请求做出响应
注: 使用forward对浏览器是透明的,浏览器不知道为其服务的servlet-1已经换成servlet-2了,它只知道发出了一个请求,获得了一个响应,浏览器地址栏上的网址是不变的。
为什么要使用forward ?
使servlet程序结构清晰,每个servlet可以做成功能单一(如:操作数据servlet、实现业务servlet),分工合作,利于程序的扩展、修改。
例1:转发的使用
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException{
RequestDispatcher rd = request.getRequestDispatcher("jsp/hello.jsp");
--- 转发到jsp/hello.jsp,这里也可以写转发到 two(servlet) rd.forward(request,response); --- req、res对象传到下一个servlet(request就共享了) request.getRequestDispatcher("/WEB-INF/html/hello.jsp").forward(req, resp);
---转发可以在WEB-INF文件夹下进行}
请求: http://127.0.0.1:8080/test/one.do --- 转发到了jsp/hello.jsp
例2: 转发清空缓冲区的问题
Servlet-1: one
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
response.getWriter().write("one-servlet"); --- 写到页面中去的
request.getRequestDispatcher("two").forward(request, response);
--- 转发到Servlet-2 }
Servlet-2: two
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
PrintWriter out =response.getWriter();
out.println("
}
请求http://127.0.0.1:8080/test/one
在这次转发时,servlet-1已经输出"one-servlet",但没显示到客户端,而是先放入缓冲区。结果只显示servlet-2的输出"
①response.getWriter() --- 获得输出流,输出流中有一个缓存区,把信息先放到缓存区里,而进行转发时会清空缓存区("one-servlet"清除掉了)。若在转发之前,已经flush,则转发操作会抛出异常,转发失效。
② servlet-1转发到servlet-2时,servlet-2先清空servlet-1的缓冲区,然后servlet-2就响应客户。注: forward必须在响应被提交给客户端之前调用(即servlet-1不响应客户),否则将抛出IllegalStateException。在forward方法调用之后,原先的响应缓存区中没有提交的内容将被自动清除。
转发的路径问题:
注:转发只能在web应用目录下转发的
request.getRequestDispatcher("jsp/hello.jsp").forward(req, resp);
在这个路径参数中前面没有加"/" , 表示相对于当前servlet的路径去转发的。
若转发路径以"/" 开始, 则是相对于当前web应用目录的路径。
request.getRequestDispatcher("/WEB-INF/html/hello.jsp").forward(req, resp);
6.4 转发、重定向的区别
1. forward(转发)是共同做一件事,分工合作,就一次请求,即request对象是共享的。
sendRedirect(重定向)是各做各的事,是2次请求,所以request对象是不共享的。
2. forward(转发): 只能在同一个web应用内部转发。
sendRedirect(重定向): 可以在同一主机上的不同web应用之间重定向,也可以重定向到其他服务器
上的web上。
6.5 绝对路径、相对路径
文件路径图
当前我在 WebRoot/WEB-INF/lib/test.xml文件里
那怎么到jsp/hello.jsp页面中去呢,用相对路径实现？
其实可以用像 dos命令一样的去理解的
所以到相对路径可以写为../../jsp/hello.jsp
我们可以用上面的dos命令去理解:
C:\WebRoot\WEB-INF\lib > cd .. C:\WebRoot\WEB-INF > cd .. C:\WebRoot > 可见第1个../到了WEB-INF目录,第2个../到了WebRoot目录下了
6.6 servletContext对象
一个ServletContext对象表示一个web应用的上下文。Servlet容器在servlet初始化期间,向其传递ServletConfig对象,通过ServletConfig对象的getServletContext()方法来得到ServletContext对象。也可以通过GenericServlet类的getServletContext()得到ServletContext对象。其实GenericServlet类的getServletContext()就是调用ServletConfig对象的getServletContext()方法来得到这个对象的。
通过ServletContext对象,servlet可以使用这些方法与servlet容器进行通信,如:得到文件的MIME类型,转发请求或向日志文件中写入日志信息。
public ServletContext getServletContext()
getRealPath(String path) --- 返回一个绝对路径见P.14. web路径问题
例: ServletContext sct = getServletContext();
--- GenericServlet类的一个方法,由于是他的继承类在子类中可以直接使用 String filename = sct.getRealPath(""); --- 获取绝对路径
7 第七章Cookie 、Session的使用
7.1 Cookie的使用
Cookie记录用户的Session信息,也可以记录用户的请求信息,也就是SessionID来分辨哪个用户是否登录过。每次登录时,不会将Cookie发送回服务器,Cookie的用来跟踪Session。
服务器可以根据Cookie来跟踪用户,对于需要区别用户的场合(如:电子商务)特别有用。为了使用安全,多数浏览器可以设置是否启用Cookie。
启用:IE 工具-->Internet选项-->安全选项卡-->自定义级别按钮
1.添加一个Cookie
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
Cookie cookie = new Cookie("key","value");
--- Cookie的信息是以键值对的形式来保存的
cookie.setMaxAge(10); --- 设置cookie的保存时间为10s。默认保存时间为-1,就是浏览器一关
闭,cookie就立即失效。
response.addCookie(cookie); --- 把cookie信息通过响应头信息带回客户端(也就是在
客户端保存cookie文件)
}
2.获得cookie信息
public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException{
Cookie[] cookies = request.getCookies();
--- 通过请求使server端得到一个cookie文件的数组,若数组无内容即无cookie,返回null if(cookies!=null){
for(int i=0;i Cookie c = Cookies[i]; if("key".equals(c.getName())){ --- c.getName()为了得到Cookie中的键的值, 这里判断"key"是为了找到本网站用的cookie文件(一般电脑上有很多网站的cookie文件) 第3章servlet 基础 1.servlet 的生命周期。 a)init方法：首次创建servlet时，它的init方法会得到调用，因此，init是放置一次 性设置代码的地方。 i.可以使用此方法进行常规初始化，用来创建或载入在Servlet生命期内用到的 一些数据，或者执行某些一次性的计算。 ii.由初始化参数控制的初始化。 要理解init参数的动机，您需要了解什么样的人可能希望对Servlet的行为方 式进行定制。其中包括：开发人员、最终用户、部署人员。 开发人员通过改变代码改变Servlet的行为。 最终用户通过向HTML表单提供数据改变Servlet的行为。 部署人员为了能够在不修改Servlet的源代码的情况下，就可以将Servlet在机 器间移动，以及改变特定的参数（例如，数据库的地址，连接共享大小，或者 数据文件的位置）。init参数的目的就是为了提供这项能力。 b)service方法：在init之后，针对每个用户请求，都会创建一个线程，该线程调用前 面创建的实例的service方法。service方法检查HTTP请求的类型（GET，POST， PUT，DELETE等）并相应地调用doGet，doPost，doPut，doDelete等方法。 c)doGet，doPost和doXxx方法 GET请求起因于正常的URL请求，或没有指定METHOD的HTML表单。POST 请求起因于特别将POST列为METHOD的HTML表单。你可以覆盖doGet和/或 doPost方法来处理。 DELETE 请求由doDelete处理，PUT 由doPut方法处理，OPTIONS 由doOptions处理，TRACE 由doTrace方法处理。OPTIONS和TRACE的请求在 Servlet中是自动支持的。 doHead以处理HEAD请求（HEAD请求规定，服务器应该只返回正常的HTTP 头，不含与之相关联的文档）。为了能够更快地生成对HEAD请求的响应（例如 来自定制客户的请求，只需要HTTP报头，不需构建实际的文档输出），会实现 doHead方法。 2.SingleThreadModel接口 a)通过让Servlet实现这个接口，系统会保证不会有多个请求线程同时访问该servlet 的单个实例。大多数和情况下，系统将所有的请求排队，一次只将一个请求转给 单个servlet实例。 b)此接口已经过时，如果要同步最好使用synchronized关键字。 第4章客户请求的处理：表单数据 1.表单数据的读取。 a)单个值的读取：getParameter(表单项名称)，表单项名称大小写敏感。如果表单项 存在但没有相应的值，返回空的String；如果没有这样的表单项，则返回null。 b)多个值的读取：getParameterValues(表单项名称)，如果同一表单项名称在表单数 据中多次出现，则应该调用getParameterValues(返回字符串的数组)。对于不存在 jsp+servlet实例 开发环境myeclipse+tomcat6 1、先创建web project，项目名为RegisterSystem， 2、在WebRoot 目录下创建login.jsp文件，只需修改body中的内容，如下所示：Servlet与JSP核心编程读书笔记
jsp+servlet实例
第一、二课 所需jar包,本次使用版本是spring3.2.3 Ps：spring的文件用上面的基本够了，但是整个过程可能需要很多的commons 软件，如fileupload，io，lang包 SpringMVC demo案例 1、加入相关jar包 2、web.xml配置
3、springMVC-servlet.xml
1 课程回顾 Servlet编程 1）Servlet生命周期（重点） 构造方法：创建servlet对象。默认情况下，第一次访问servlet对象时。只调用1次。 init方法（有参）：创建完servlet对象后调用。只调用1次。 注意：会调用无参的init方法。 service方法：servlet提供服务的方法。每次发出请求调用。 注意：request对象，response对象 destroy方法：tomcat服务器停止或web应用重新部署，servlet对象销毁，destroy方法被调用。 2）ServletConfig对象 获取servlet的初始化参数： getInitParameter("name "); getInitParameterNames(); 3）ServletContext对象 得到web应用路径： context.getContextPath(); request.getContextPath(); 等价于上面的代码 得到web应用参数： context.getInitParameter("name"); context.getInitParameterNames(); 域对象: context.setAttribute("name",Object): 保存数据 context.getAttribute("name") 得到数据 context.removeAttribue("name") 清除数据 转发 context.getRequestDispatcher("路径").forward(request,response); request.getRequestDispacher("路径").forward(request,response); 等价于上面的代码得到web应用中的资源文件 context.getRealPath("路径") context.getResourceAsStream("路径"); 今天的目标：会话管理 2. 会话管理入门 2.1 生活中会话 我：小张，你会跳小苹果码？ 小张：会，怎么了？ 我：公司年会上要表演节目，你教教我把 小张：没问题，一顿饭而已。 我：OK。 。。。。。。。。
第一课 第二课tomcat 简单模拟
package com.my.first; import java.io.*; import https://www.doczj.com/doc/ba13511652.html,.*; publicclass Mytomcat { /** * @param args */ publicstaticvoid main(String[] args) throws Exception { ServerSocketss = new ServerSocket(9999); Socket s = ss.accept(); System.out.println("在9999上等待。。。"); OutputStreamos =s.getOutputStream(); BufferedReaderbr = new BufferedReader(new FileReader("f:\\hello.html")); String str=""; while((str = br.readLine())!=null){ os.write(str.getBytes()); } br.close(); os.close(); s.close(); // ss.close(); } } 在浏览器中输入 http://localhost:9999 就会出现“hello world” 第三课 启动tomcat 各种问题总结
第四课
第五课 虚拟目录 如在f盘存放着各种web应用，但是空间不够了，这是我在d盘弄个文件当做该web应用的文件。但是要在server.xml中指定一下。 步骤：1、在那个磁盘下建立“f:\web2”，并建立相关的资源文件 2、在server.xml中配置
JSP基础语法 一、 JSP基础语法 (5) 1. JSP注释 (5) (1) (5) (2) <% //注释 %> (5) (3) <%-- 注释 --%> (5) 2. JSP脚本代码 (5) (1) 定义全局变量、方法、类 (5) (2) 定义局部变量、或编写Java语句 (5) (3) 输出语句 (5) 3. page指令 (5) (1) page指令语法 (5) (2) page指令例子 (5) ● 设置MIME类型(contentType属性) (6) ● 设置编码(pageEncoding属性) (6) ● 错误页的设置(errorPage属性) (6) ● 导包操作(import属性) (6) 4. JSP动作指令 (6) (1) JSP的7个动作指令 (6) (2) 跳转指令(jsp:forward) (6) ● jsp:forward语法 (6) ● 例子 (6) (3) 参数传递指令(jsp:param) (6) ● jsp:param语法 (6) ● jsp:param指令的作用 (6) (4) 包含指令(jsp:include) (6) ● 静态包含(include不常用) (6) ● jsp:include语法 (6) ● 动态包含(
Struts1 (1) Struts1和Servlet的关系 (1) 创建第一个Struts1项目 (1) 例子1: (3) 总结重点：struts1的工作流程（基于MVC模式的） (7) 一．普通的Servlet的工作流程 (7) 二．Structs1的工作流程（和上面的对比记忆） (8) Struts标签 (9) Bean标签 (9) html标签 (10) logic标签（逻辑标记） (12) i18n（国际化） (13) Struts1 Struts1和Servlet的关系 Jsp+Servlet+Javabean ActionForm和VO的区别： 一样的内容，不一样的作用 ActionForm只接收前台表单传来的数据 VO是conga后台提取的数据向前台传递 创建第一个Struts1项目 新建一个web项目，选择1.4即可 右键----MyEclipse----Add Struts Capacity
---------------Struts控制文件的路径 TLD（标签） 1） 2）
①spring是什么? struts 是 web 框架 (jsp/action/actionfrom) hibernate 是 orm框架,处于持久层. spring 是容器框架,用于配置bean,并维护bean之间关系的框架 ?spring中有一个非常概念: bean (是java中的任何一种对象javabean/service/action/数据源./dao, ioc(控制反转inverse of control) di( dependency injection 依赖注入) ?画一个框架图 快速入门 开发一个spring项目. 1.引入spring的开发包(最小配置该包把常用的jar都包括, 还要写日志包 2.创建spring的一个核心文件 , [hibernate有核心 struts核心文件 ], 该文件一般 放在src目录下,该文件中引入 xsd文件： 可以从给出的案例中拷贝一份. 3.配置bean
J2EE学习笔记 注：框架可以用Word菜单中的“视图/文档结构图”看到 J2EE模式 Value Object(值对象) 用于把数据从某个对象/层传递到其他对象/层的任意Java对象。通常不包含任何业务方法。 也许设计有公共属性，或者提供可以获取属性值的get方法。 JSP 1．JSP的基础知识 __ _____ | directive (指令) | |-- scripting （脚本） JSP -------| |__ action （动作） | |_____Template data ：除JSP语法外，JSP引擎不能解读的东西 1）在JSP中使用的directive(指令)主要有三个： a)page指令 b)include指令 c)taglib指令 在JSP的任何地方，以任何顺序，一个页面可以包含任意数量的page指令 2)Scripting（脚本）包括三种类型 a)<%！declaraction %> b)<% scriptlet %> c)<%= expression %> 3)action（动作） 标准的动作类型有： a)
e)
1.Java语言中，字符串是对象类型，而字符是数据类型。 2.一旦使用了关键是strictfp来申明某个类、接口或者方法时，那么在这个关键字所声明 的范围内所有浮点运算都是精确的，符合IEEE-754规定的。如果一个类被声明为strictfp，那么该类中所有的方法都是strictfp。 3.String s1 = new String(“abc”) 该语句创建了两个对象。”abc”被创建与文字池中，s1在堆中被创建。 4.数组不能直接指定列数或者行数，应在创建对象时指定。Int iArray[][] = new int[3][4]。 5.请描述Java Servlet API中forward()与redirect()的区别？ 答：前者仅是容器中控制权的转向，在客户端浏览器地址栏中不会显示出转向后的地址。 后者则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。所以，前者更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。在有些情况下，比如，需要跳转到一个其他服务器上的资源，则必须使用sendRedirect()方法。 6.JSP和Servlet有哪些相同点和不同点？它们之间的联系是什么？ 答：JSP是Servlet技术的扩展，本质上是Servlet的简易方式，更强调应用的外表表达。 JSP编译后是”类Servlet”。Servlet和JSP最主要的不同点在于，Servlet的应用逻辑是在Java文件中，并且完全从表示层中的HTML里分离出来。而JSP的情况是Java和HTML 可以组合在一个扩展名为.jsp的文件。JSP侧重于视图，Servlet主要用于控制逻辑。 7.Servlet执行时一般实现哪几个方法？ 答：public void init(ServletConfig config) Public ServletConfig getServletConfig() Pubic String getServletInfo() Public void service(ServletRequest request, ServletResponse response) Public void destroy() 8.请简介依赖注入机制。 答：所谓依赖注入，是指程序运行过程中，如果需要调用另一个对象协助，无须在代码中创建被调用者，而是依赖于外部的注入。Spring的依赖注入对调用者和被调用者几乎没有任何要求，完全支持对POJO之间的依赖关系的管理。依赖注入通常有两种：设值注入和构造注入。 9.Hibernate的优点是什么？ 答：Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲地使用对象编程思维来操纵数据库。Hibernate 可以应用在任何使用JDBC的场合，既可以在Java的客户端使用，也可以在Servlet/Jsp 的Web应用中使用。最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP,完成数据库持久化的任务。 10.Session和Cookie的区别和联系。 答：cookie机制采用的是在客户保持状态的方案，而session机制采用的是在服务器端保持状态的方案。
Java： Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。 Java JDK 9学习笔记： 《Java JDK 9学习笔记》是作者多年来教学实践经验的总结，汇集了学员在学习Java 或认证考试时遇到的概念、操作、应用等问题及解决方案。 基本信息： 《Java JDK 9学习笔记》是作者多年来教学实践经验的总结，汇集了学员在学习Java 或认证考试时遇到的概念、操作、应用等问题及解决方案。《Java JDK 9学习笔记》针对Java SE 9 新功能全面改版，无论是章节架构或范例程序代码，都做了重新编写与全面翻新，并详细介绍了Java 9 的模块化，JVM、JRE、Java SE API、JDK 与IDE 之间的对照关系。必要时可从Java SE API 的源代码分析，了解各种语法在Java SE API 中如何应用。对于建议练习的范例提供了Lab 文档，以突出练习重点。此外，《Java JDK 9学习笔记》还将IDE 操作纳为教学内容之一，让读者能与实践相结合，轻松快速掌握Java 编程技巧。《Java JDK 9学习笔记》适合Java 的初、中级读者以及广大Java 应用开发人员阅读。 作者简介： 林信良（网名：良葛格），毕业于台湾大学电机工程学系。擅长
技术写作、翻译与教育培训。喜好研究程序语言、框架、社群，从中学习设计、典范及文化，并利用闲暇之余记录所学技术，涵盖C/C++、Java、Ruby/Rails、Python、JavaScript、Haskell、OpenSCAD 等领域。目前出版的著作有《JSP & Servlet学习笔记（第2版）》《Spring技术手册》《Java JDK 8 学习笔记》等，译作有《Ajax实战手册》《jQuery实战手册（第2版）》。
weblogic培训笔记（转载） 上一篇/ 下一篇 2009-05-21 16:29:55 / 个人分类：服务配置 查看( 97 ) / 评论( 0 ) / 评分( 0 / 0 ) weblogic Server内部结构和相关的配置 weblogic Server内部结构图： (一) 原理简单说明 服务器启动，就会绑定到相应的端口，并为一个端口分配一个线程以接受连接请求，一旦服务器接受到连接请求并建立好连接以后，监听线程将处理权交给套接字复用器，套接字复用器进行一定的处理，并会负责选择利用那个执行队列并将请求置入其中。当有一个请求进入执行队列，就会有一个空闲的执行县城从该队列里面取走并向调用者返回结果。 (二) 执行队列和执行线程的相关配置 执行线程数量有一定的限制，在服务器启动的时候，就已经形成了一个含有一定数量执行线程的池，执行线程可能跨servlet，ejb和jdbc等，由于执行线程仅当程序成功结束或者出现异常才能被释放继续处理其他请求，所以如果执行线程执行的不够快，而请求又多的情况下，就会造成执行队列的阻塞。 相关的配置信息有：
server菜单—〉configuration页---〉高级配置---〉Config Execute Queues中的配置项如下： 1、Queue Length队列长度，执行队列的长度 2、Queue Length Threshold Percent 一个百分数，当request的数量达到队列长度的这个比例的时候，weblogic会发出overflow的标志信息。 3、Thread Count 服务器初始创建的执行线程的数量 4、Thread Increase 如果weblogic发出overflow的标志信息，weblogic会尝试增加这个数量的执行线程，以解决处理矛盾。 5、Threads Maximum最大执行线程数 6、Threads Minimum最小执行线程数 7、Thread Priority线程优先级 另外server菜单—〉configuration页---〉tuning子页中还有一些相关的配置： 1、 Stuck Thread Max Time 黏联线程时间，超过这个时间没有返回的执行线程，系统将认为是黏联线程。 2、 Stuck Thread Timer Interval 系统检查黏联线程的时间间隔 如果weblogic认为某个队列中的所有的线程全部黏联的话，weblogic将会增加执行线程的数量。 注意：执行线程的数量一旦增加，目前weblogic不会去减少他，如果增加了一些线程以后再次出现overflow 的警告，weblogic会继续增加执行线程的数量，一直到达到上限为止。 (三) 套接字复用器的相关配置
韩顺平jsp学习笔记 jsp u j2ee核心13种技术： 程序员必须掌握的技术：java，servlet，jsp。 13种技术规范. u j2ee程序员修炼成精法门 u jsp 版本的用户管理系统：将servlet版本改为jsp版本，只使用jsp技术完成（modle1模式开发） 并且在后面可通过jsp版的用户管理系统的改写，非常自然过渡到mv设计模式，更进一步到mvc设计模式 开发工具：myeclipse u jsp概述: jsp是servlet技术的补充，访问jsp的过程：如果是第一次访问，jsp文件被服务器翻译成一个对应的java文件(servlet)，然后，再被编译成.class文件并加载到内存中。如果是以后访问jsp，那就直接调用内存中的jsp实例，所以，第一次访问jsp慢，后面访问jsp的速度就会变快了。（hello.jsp来说明运行原理：tomcat下的work下有将jsp转换为servlet的代码） 1. 为什么出现：程序员在开发过程中，发现servlet做
界面非常不好,jsp对servlet的补充（对界面的补充，jsp界面好做） 2. jsp=html+java片段+jsp标签（语法）+javascript（css）:综合 3. jsp功能的强大是因为可以与javabean结合使用(即：jsp作前台(界面)，javabean作后台(逻辑层))。 4. Jsp是什么：1.jsp运行在服务器，2.jsp（java server page）3。Jsp基础是servlet（相当于对servlet的包装）4.jsp 是综合技术：一个公式：jsp=html+java代码+jsp标签 +javascript(css) 比较综合5.jsp无需配置，直接使用，如果你修改了jsp文件，不需要重新reload web应用6.jsp如何访问：http://ip:8088/web应用名.jsp路径u jsp的概述：元素 1. 指令元素 2. 脚本元素 3. 动作元素 u jsp与servlet的关系： 1. jsp与servlet是对应关系 2. jsp是以servlet为基础的 u 编写一个计算器的实例: 1. 表单提交处理的jsp页面为：<form action=”chuli.jsp”>
1、02_尚学堂马士兵_Struts2_Struts2_HelloWorld_2.avi 指定Tomcat的目录，指定JDK搭建开发环境（拷贝jar包，复制struts.xml 文件此文件不要放在WEB-INF下面，应该放到src下面），在web.xml文件中：
java基础学习心得 java基础 1.java程序是由1个或者n个class组成的程序 2.编写---javac进行编译------java进行执行 3.类名的命名：规范：第一个字母要大写第一字母必须是字母下划线美圆符号人民币符号// 4.不是第一个字母的话可以是数字 5.文件名和类名的关系如果class前面没有public 是可以不一样的但是如果有的话必须一样 6.两个byte short类型进行加减乘除的时候返回的结果是int类型 /* 需求：定义一个hello world小程序。 步骤： 1，通过class关键字定义一个类。将代码都编写到该类中。 2，为了保证该的独立运行。在类中定义个主函数。格式public static void main(string args) 3,保存成一个扩展名为java的文件。 4，在dos控制台中通过javac工具对java文件进行编译。 5，在通过java命令对生成的class文件进行执行。 */ class demo//定义一个类。 { //主函数。 public static void main(string args) { //输出语句。 system.out.println(); } } 6.字符串数据和任何数据使用+都是相连接，最终都会变成字符串。 system.out.println(+(5+5));// 转义字符：通过来转变后面字母或者符号的含义。 n:换行。 b:退格。相当于backspace。
r:按下回车键。window系统，回车符是由两个字符来表示rn. t:制表符。相当于tab键。 7.if else 结构简写格式：变量 = (条件表达式)?表达式1：表达式2； 三元运算符： 好处：可以简化if else代码。 弊端：因为是一个运算符，所以运算完必须要有一个结果。 class operatedemo { public static void main(string args) { int x= 7; //逻辑运算符用于连接boolean类型的表达式。 //x>3 & x第三篇：java学习心得笔记 j2ee学习笔记 注：框架可以用word菜单中的“视图/文档结构图” 看到 j2ee模式 value object(值对象)用于把数据从某个对象/层传递到其他对象/层的任意java对象。 通常不包含任何业务方法。 也许设计有公共属性，或者提供可以获取属性值的get方法。 jsp 1．jsp的基础知识 __ _____ |directive(指令) | |-- script(敬请期待好范文网更好文章：https://www.doczj.com/doc/ba13511652.html,)ing jsp -------| |__ action | |_____template data ：除jsp语法外，jsp引擎不能解读的东西 1）在jsp中使用的directive(指令)主要有三个： a) page指令 b) include指令 c) taglib指令 在jsp的任何地方，以任何顺序，一个页面可以包含任意数量的page指令 2)scripting包括三种类型
JSP 期末考试题 程序员笔记精华 针对以下题目请选择正确的答案（每道题目有一个或多哥正确的答案）。每一道题目，所有答案都选对，则该题加分，所选答案错误或不能选出所有正确答案，则该题不得分。 1）在JSP中，要定义一个方法，需要用到以下（）元素。（选择一项） a) <%= %> b) <% %> c) <%! %> d) <%@ %> 2）JSP页面经过编译之后，将创建一个（）。（选择一项） a) applet b) servlet c) application d) exe文件 3）当JSP页面执行自定义标签，遇到结束标签时将调用()方法执行处理。（选择一项） a) doStartTag() b) doEndTag() c) doInitBody() d) doAfterBody() 4) 在J2EE中，test.jsp文件中有如下一行代码：（选择一项）
！ Struts视频笔记: Struts是一个开源的web框架,框架提高了程序的规范的同时也约束了程序员的自由 为什么会有struts: 因为我们队mvc理解的不同,可能造成不同公司写程序的时候,规范不统一,这样不利于程序的维护和扩展,所以我们有必要用一个统一的规范来开发项目(struts) Struts 的好处: 程序更加规范化,开发效率提高了,可读性增加了,程序的可维护性增加了 ^ 运行原理: 一个请求从浏览器发送给ｗｅｂ服务器,,web服务器首先解析主机然后解析web应用的名称 在解析出资源名转发给总司令ActionServlet(该类由struts框架提供给我们的无需编写,只需配置)ActionServlet有一个文件,该文件配置了表单actionForm(军火库),还配置了action,以及他们之间的对应关系,当ActionServlet拿到命令后它会查询文件去填充数据,把用户的数据填充到表单里边,下个动作就是去调用指定的action(小队长),action去从表单中读取数据,调用某个model(士兵,如service)完成任务,完成任务把结果返回给ActionServlet总司令(返回一个执行的结果),-->总司令又去查询文件,决定跳转到哪个jsp页面,返回一个执行结果(形成静态html文件)直接返回给web服务器服务器再把静态页面以h ttp响应给浏览器 ,登录小项目过程步骤: 新建ｗｅｂ工程导入struts包编写编写actionForm和action 配置编写和配置测试 中的