java Web笔记

如何现实servlet的单线程模式
答：<%@ page isThreadSafe="false"%>

★设置虚拟目录：
<Context  path="/test" docBase="本机绝对路径" reloadable="true" />
reloadable="true"表示服务器能自动读取修改后的javaBean，否则需要重启
★注释：
★声明语句：
★表达式：
★脚本段：此处声明的变量是局部变量，而在声明语句中声明的变量是全局变量：<%! %>
★page指令：
 <%@ page contentType="text/html;charset=gb2312"%>
 <%@ page import="java.io*;"%>
 <%@ page isErrorPage="true"%>
 <%@ page errorPage="error.jsp"%>
 <%@ page session = "true"%> //session管理
 <%@ Page isAutoFlush="true"%>
 <%@ page buffer="8kb"%>
 isErrorPage(是否能使用Exception对象)，isELIgnored(是否忽略表达式)

★include指令：
 <%@ include file="任意文件"%>  //包含的只是文件内容，跟文件格式无关
★include标签：<jsp:include page=""/>
注意include指令与include标签的区别：
1.一个先全部包含在一起执行，一个是先执行，再把结果包含进去。
2.使用include标签可以向被包含的jsp动态页面传递参数,
  如何向被包含页面传递参数呢：<jsp:param name="" value=""/>
 被包含页面接收参数使用：request.getParameter("");
 
★JSP 共有以下6种基本动作标签：
 jsp:include：在页面被请求的时候引入一个文件。
 jsp:useBean：寻找或者实例化一个JavaBean。
 jsp:setProperty：设置JavaBean的属性。
 jsp:getProperty：输出某个JavaBean的属性。
 jsp:forward：把请求转到一个新的页面。
 jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记。

★跳转语句：
<jsp:forward page="">
 <jsp:param name="参数名称" value=""/>  //可以传递参数
</jsp:forward>
此跳转语句属于服务器无条件跳转，跳转之后地址栏不会改变

★jsp的9个内置对象及各自用途：
与servlet有关的对象：
|-page     表示从该页面产生的一个servlet实例
|-config 。该对象用于存取servlet实例的初始化参数
与IO有关的隐含对象：
|-out
|-request 负责客户端的请求或其他如ip等信息，并且提供了几个用于获取cookie, header, 和session数据的有用的方法
|-response 设置送回 浏览器的响应的方法（如cookies,头信息等
jsp执行时与内容有关的：
|-session
|-application
|-pageContext
与error错误有关的：
|-exception
★4种页面属性保存范围：
  page:一个页面范围
  request：一次服务器请求范围
  Session：一次会话范围
  application：一个应用服务器范围
★如何解决中文乱码问题：
方法一：设置page属性：charset=gbk
方法二：通过String类中的getBytes(“编码”)方法
 String name = new String(request.getParamter("uname").getBytes("gbk"));
 或者：String name = new String(myStr.getBytes("ISO-8859-1"),"gbk");
方法三：设置统一请求编码：request.setCharacterEncoding("gbk");
★接收客户端请求参数：request.getParameter("表单name值");
 但要是接受的是复选框或者是下拉列表，该如何接收呢？？
 String hoby[] = request.getParameterValues(String[] name);该方法返回的是一个字符串数组
★地址重写：demo.jsp?uname=xia&upassword=530
★response功能：
1.设置头信息：
 response.setHeader("refresh","3");
 response.setHeader("refresh","3;URL=跳转页面");
2.跳转，重定向：response.sendRedirect("跳转路径")
 这种跳转是客户端跳转，地址栏改变，而且此种跳转不能保存request属性，而且是所有代码执行完之后再跳转的。
 因为request范围是只保存在一次服务器跳转中，而且是forward跳转才能被保存，像这里的response.sendRedirect("路径")
 就不能保存request值。
 同时注意一下RequestDispatcher跳转，这中跳转是用于Servlet中跳转的，而上面讲的是用于jsp跳转。
3.设置Cookie
response.addCookie(new Cookie("password","530"));
Cookie coo[] = request.getCookies();
如果要取得相应cookie对象的值，Cookie对象中有相应getName(),getValue()方法。

★session对象：常用方法
session.getId();
session.isNew();
session.getAttribute();session.setAttribute();session.removeAttribute();
session保存在服务器上，而Cookie存放在客户端。前者比Cookie更安全，但是比Cookie更耗资源。开发原则：尽量少使用session。
session使用的是cookie机制，所以如果用户禁用了Cookie，session也将无法使用。

★application对象
application.getRealPath("/");//注意这里需要一个参数：/
但是开发中往往使用getServletContext()(该方法由容器直接提供)替代application：getServletContext().getRealPath("/");
★out对象：开发中都使用<%=%>代替out.println()；
★config对象：使用该对象必须先在WEB-INF文件夹下web.xml文件中进行配置才能使用。
WEB-INF文件夹具有高安全性，里面文件不能直接被访问到。如果在该文件夹下放置了一个demo01.jsp文件，能被访问到吗？？
如果要被访问到，需要按如下方法更改WEB-INF文件夹下web.xml文件就行：但是这种方法呢需要在地址栏手动输入地址才能被访问到。
<servlet>
 <servlet-name>1233</servlet-name>
 <jsp-file>/WEB-INF/demo01.jsp</jsp-file>
</servlet>
<servler-mapping>
 <servlet-name>1233</servlet-name>
 <url-pattern>/mytest</url-pattern>
</servler-mapping>
这时在地址栏中输入：http://localhost:8080/test/mytest就打开了demo01.jsp这个页面了。
使用config对象前必须先在WEB-INF文件夹下web.xml文件中进行配置才能使用：
 <servlet>
  <servlet-name>122</servlet-name>
  <jsp-file>/WEB-INF/demo01.jsp</jsp-file>
  
  <init-param>
   <param-name>uname</param-name>
   <param-value>wjr</param-value>
  </init-param>
  <init-param>
   <param-name>upassword</param-name>
   <param-value>530</param-value>
  </init-param>
 </servlet>
 <servlet-mapping>
  <servlet-name>122</servlet-name>
  <url-pattern>/mytest</url-pattern>
 </servlet-mapping>

取得上面设置的初始化参数方法：
String name = config.getInitParameter("uname");
String password = config.getInitParameter("upassword");
但是注意，上面的初始化参数只能在/WEB-INF/demo01.jsp中取得。

★如何设置默认网页：修改tomcat下conf的web.xml文件，修改其中的<welcome-file-list>标签内容

★jdbc驱动：注意启动文件存放位置
可以放在项目lib文件夹下，也可以放在D:/apache-tomcat-5.5.12/common/lib中
连接Oracle数据库：驱动：oracle.jdbc.driver.oracleDriver
    连接地址：jdbc:oracle:thin:@localhost:1521:huan

★javaBean知识点：
☆使用javaBean时注意事项：
1.所有javaBean必须放在包路径中
2.javaBean必须声明为public class
3.所有属性必须封装，设置和获取采用setter()和getter()
使用jsp调用javaBean时必须有个无参构造方法

☆jsp如何使用javaBean：
  采用<jsp:useBean />标签：<jsp:useBean id="per" scope="page" class="cn.demo.Person"/>
☆jsp如何设置javaBean属性呢？？4种方法：
方法一：
<jsp:setProperty name="per" property="*" />  //自动匹配
如果有一个登录表单页面，有uname和upass两个text控件，那么上面那行代码就代替了下面的代码：
per.setName(request.getParameter("uname"));
per.setPass(request.getParameter("upass"));
方法二：
当然，如果javaBean属性按如下设置，则只会对已设置的属性赋值，没设置的值为null。
<jsp:setProperty name="per" property="uname" />  //按自己需求设置相应的属性
方法三：
你也可以给某个属性赋一个参数，让它按你自己意愿接收某个值：
<jsp:setProperty name="per" property="uname" param="upass"/>
<jsp:setProperty name="per" property="upass"  param="uname"/>
方法四：
如果你想给所选的属性设置页面没有的值，或者你自己想设的值，那么可以使用如下方法：
<jsp:setProperty name="per" property="uname" value="wjr"/>
<jsp:setProperty name="per" property="upass"  value="530"/>
这里需要注意的是，如果给value传递的值是一个变量，那么这时就需要表达式才行。
如：String uname = "wjr";
<jsp:useBean name ="per" property="uname" value="<%=uname%>"/>

☆jsp如何取得javaBean属性：取得属性是没有自动匹配的，必须需要哪个就取哪个：
<h2>用户名是：<jsp:getProperty name="per" property="uname"/></h2>
上面这行就取代了jsp中的如下代码：
<h2>用户名是：<%=per.getUname()%></h2>

☆javaBean的另一个重要特性：
  就是使用javaBean的setProperty()方法，可以自动将传递过来的只有数字的字符串，变为整型，然后再赋给相应的属性。
  例如：Person中有个一int类型的age属性，但是表单接收的确是一个如“24”的字符串数字，但是当你设置属性时就不需
        要转化了,因为javaBean的setProperty()方法会自动转换：<jsp:setProperty name="per" property="age">

★servlet知识点：
☆servlet其实就是通过java编写的cgi程序（通用网关接口），但是与普通cgi不同的是servlet采用的是多线程，所以效率更高,
  但是不安全的。Servlet的线程安全问题只有在大量的并发访问时才会显现出来，并且很难发现，因此在编写Servlet程序时要特别注意。线

程安全问题主要是由实例变量造成的,因此在Servlet中应避免使用实例变量。如果应用程序设计无法避免使用实例变量，那么使用同步来保护

要使用的实例变量，但为保证系统的最佳性能，应该同步可用性最小的代码路径。
 Servlet体系结构是建立在Java多线程机制之上的，它的生命周期是由Web容器负责的。当客户端第一次请求某个Servlet时，Servlet

容器将会根据web.xml配置文件实例化这个Servlet类。当有新的客户端请求该Servlet时，一般不会再实例化该Servlet类，也就是有多个线程

在使用这个实例。Servlet容器会自动使用线程池等技术来支持系统的运行。这样，当两个或多个线程同时访问同一个Servlet时，可能会发生

多个线程同时访问同一资源的情况，数据可能会变得不一致。所以在用Servlet构建的Web应用时如果不注意线程安全的问题，会使所写的

Servlet程序有难以发现的错误。
 
☆什么是cgi：CGI全称是Common Gateway Interface，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，
             其程序须运行在网络服务器上。

☆servlet生命周期：
 ◎初始化时期，第一次使用servlet时初始化，也可以在容器启动时初始化，但是需要配置配置WEB_INF下的web.xml文件：
   <servlet>
  <servlet-name>simple</servlet-name>
  <servlet-class>cn.wjr.SimpleServlet</servlet-class>
  <load-on -startup>1</load-on -startup>  //数字1表示启动优先级，0表示最优先级。
   </servlet>
 ◎执行期，
 ◎结束期（服务器关闭或则长时间不使用该servlet就会自行销毁）
☆servlet映射文件，需要配置WEB_INF下的web.xml文件：
 servlet>
  <servlet-name>simple</servlet-name>
  <servlet-class>cn.wjr.SimpleServlet</servlet-class>
 </servlet>
 <servlet-mapping>
  <servlet-name>simple</servlet-name>
  <url-pattern>/SimpleServlet</url-pattern>
 </servlet-mapping>
 当你的表单文件在根目录下login文件夹下时，表单文件中的<form action="LoginServlet">还是不变，只需要更改配置文件中
 的<url-pattern>属性就可以了：<url-pattern>/login/SimpleServlet</url-pattern>
☆servlet本身为jdk的扩展包，如果编译时找不到servlet包问题，但是tomcat提供了所有servlet包
 D:/apache-tomcat-5.5.12/common/lib把servlet-api.jar拷贝到D:/jdk1.5.0/jre/lib/ext目录下即可。
☆servlet缺点就是不太适合输出大量代码。
☆上面提到的初始化方法是指的是一个带参数的初始化方法：public void init(ServletConfig config) throws ServletException {}
但是servlet还有个无参的初始化方法：public void init() throws ServletException {}，这两种初始化方法有什么区别啊
当有init(ServletConfig config)方法时，init()就无效了，
一般需要传递参数的时候就使用有参初始化方法，当不需要传递初始化方法时就使用init()方法，具体怎么传递参数详见后面讲解。

☆servlet还有个优点就是一个servlet可以映射多个路径：
  <servlet>
    <servlet-name>Ssss</servlet-name>
    <servlet-class>rge.Ssss</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>Ssss</servlet-name>
    <url-pattern>/servlet/Ssss</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>Ssss</servlet-name>
    <url-pattern>/servlet/*</url-pattern>  //*号表示任意匹配
  </servlet-mapping>
只要在地址栏中输入：http://localhost:8080/test/servlet/469就能访问了。
☆这里讲解如何向init(ServletConfig config)初始化方法中配置初始化参数：
 你看下面就知道：在ServletCongfig中配置初始化参数跟jsp中设置config对象初始化参数是一样的：
   <servlet>
  <servlet-name>simple</servlet-name>
  <servlet-class>cn.wjr.SimpleServlet</servlet-class>
  <load-on -startup>1</load-on -startup>  //数字1表示启动优先级，0表示最低优先级。
  <init-param>
   <param-name>driver</param-name>
   <param-value>oracle.jdbc.driver.Oracle</param-value>
  </init-param>
  <init-param>
   <param-name>user</param-name>
   <param-value>scott</param-value>
  </init-param>
  <init-param>
   <param-name>password</param-name>
   <param-value>tiger</param-value>
  </init-param>
   </servlet>
如何得到配置的初始化参数呢：
public void init(ServletConfig config) throws Exception
{
 String dbDriver = config.getInitParameter("driver");
}
当然，也可以在doGet()或doPost()方法中使用：String dbDriver = config.getInitParameter("driver");
☆注意配置映射路径问题：
 如果一个表单文件在根目录下的servlet目录下，这时映射文件为:<url-parttern>/formServlet</url-parttern>,
 那么这时表单文件中的action="../formServlet";这样写../很麻烦，可以这样：
 映射文件改为:<url-parttern>/servlet/formServlet</url-parttern>,这时表单文件就只需要写为：
 action="formServlet";
☆如何取得各种属性对象：
public void doPost(HttpServletRequest req,HttpServletResponse resp)
{
 String name = req.getParameter("uname");
 //取得session对象
 HttpSession session = req.getSession();
 session.setAttribute("sname",name);
 //取得application对象
 ServletContext app = this.getServletContext();
 app.setAttribute("addr","成都人民南路");
}
在另一个jsp页面如何取得上面设置的属性呢：
<h2><%=session.getAttribute("sname")%></h2>
<h2><%=getServletContext().getAttribute("addr")%></h2>
<h2><%=application.getAttribute("addr")%></h2>         //和上面这句是一样的
对于application对象而言：如果Servlet初始化使用的是init(ServletConfig config)方法；那么该application对
象就必须通过config对象来实例化:ServletContext app = this.config.getServletContext();
☆那servlet到底有什么用呢？？要使用mvc模式才能体现。

☆jsp+servlet+javaBean模式：（适合团队开发）
 单独的jsp+javaBean模式：（适合快速开发）jsp与javaBean代码耦合度太高，维护困难，程序员与美工很难分工
 而jsp+servlet+javaBean能较好解决这类问题：
 jsp优点：显示方便，便于ui开发
 Servlet优点：实质就是java程序，所以安全性高性能也高。
 Servlet缺点：显示不方便
 但是Servlet也能像jsp那样接收用户请求的参数
 javaBean优点：可重复调用，但是需要接收用户请求的参数进行相应处理
 
  MVC的各个部分都有那些技术来实现?如何实现?
 MVC 是Model－View－Controller的简写。"Model" 代表的是应用的业务逻辑（通过JavaBean，EJB组件实现）， "View" 是应用的表

示面（由JSP页面产生），"Controller" 是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示

逻辑分成不同的组件实现。这些组件可以进行交互和重 用。

☆jsp跳转到Servlet可以通过表单或者超链接两种方法都可以。
  Servlet跳转到jsp可以通过response对象，但是注意这种跳转不能保request对象属性。解决方法之一可以把属性范围扩大
  为session范围：
  String name = request.getParameter("uname");
  HttpSession session = request.getSession();  //要先从request对象中取得session对象。
  session.setAttribute("sname",name);
 但是如果这个值只需要保存在一次跳转中，那么上面这种扩大为session范围只要与服务器一直连接，那么该内存块就
        一直被赞占用，浪费了资源。如何解决这种问题呢？？
jsp中采用了RequestDispatcher接口来解决此问题。实例化该对象要使用参数request.getRequestDispatcher();
现在response.sendRedirect("MyJsp.jsp")这句话就可以这样被代替了：
 RequestDispatcher rd = req.getRequestDispatcher("MyJsp.jsp"); //注意传进去的参数就是你要跳转的页面
  这样写之后还是不能跳转成功的，因为在RequestDispatcher接口中真正实现跳转的是接口中的include和forward方法，
一般使用forward方法跳转，所以现在：rd.forward(req,resp);这样之后就能成功跳转了。
这中通过该接口跳转的方式也属于服务器跳转，只不过它属于Servlet中的跳转而不是jsp中的服务器跳转。
☆Servlet程序分类：
1.标准Servlet
2.过滤Servlet
3.监听Servlet
过滤Servlet要求类实现Filter接口，该接口中有init(),doFilter(),destroy()三个方法，其中
doFilter(ServletRequest request, ServletResponse response, FilterChain chain)方法传递的参数是标准Servlet中
传递的参数HttpServletRequest和HttpServletResponse的父类，也就是说过滤Servlet能处理除http请求之外的所有其他请求。
现在定义了一个过滤Servlet：public class MyFilter implements Filter{},那该如何配置过滤器Servlet呢?跟标准Servlet一样，
只是把Servlet标签换成filter就行了：
<filter>
    <filter-name>fil</filter-name>
    <filter-class>filter.MyFilter</filter-class>
  </filter>
  <filter-mapping>
    <filtert-name>fil</filter-name>
    <url-pattern>/*</url-pattern>  此处的路径表示对哪个页面进行过滤，这里的*表示法表示对所有页面进行过滤。
  </filter-mapping>
如果上面MyFilter 中的doFilter()方法中就只有一句System.out.println("过滤器成功执行！")，
那么启动运行之后，能正常打印该语句，但是所有页面都被过滤了，也都看不见所有页面了。这时就需要把过滤器要传递的内容往下
继续传递。实现这一目的就需要doFilter()方法中的FilterChain  chain参数了，需要在doFilter()方法中这样使用该参数：
    chain.doFilter(request,response); //意思就是把请求的参数继续往下传递。
过滤Servlet主要功能：
1.屏蔽非法内容如文字等
2.统一字符编码：
request.setCharacterEncoding("gb2312");
chain.doFilter(request,response);

☆如何在过滤Servlet中使用session对象，同样跟标准Servlet一样需要通过Request获得session对象，但是不同的是过滤Servlet需
  要先转换类型。因为Session属于http范围，而过滤Servlet中的Request对象是属于ServletRequest对象，所以需要转换为     

HttpServletRequest对象：
  HttpServletRequest req = (HttpServletRequest)request;  //此处的request就是doFilter()方法中的ServletRequest。
  HttpSession session = req.getSession();
过滤Servlet中跳转同样使用RequestDispatcher:
request.getRequestDispatcher("login.jsp").forward(requset,response);

监听Servlet：指针对于整个web环境的监听，主要有以下3类：
1.ServletContext：Servlet上下文
2.Session：对Session监听
3.Request监听
要实现监听，就是实现一系列监听接口。
一.ServletContext监听：需要实现ServletContextListener接口和ServletCOntextAttributeListener接口。
ServletContextListener接口：对整个Servlet上下文监听。
        该接口有启动、销毁监听两方法：
 contextInitialized(ServletContextEvent sce)
 contextDestroyed(ServletContextEvent sce)
  参数ServletContextEvent事件：表示取得一个ServletContext（application）对象：
  public ServletContext getServletContext();
ServletCOntextAttributeListener接口：表示对Servlet上下文属性的监听
 属性增加：attributeAdded(ServletContextAttributeEvent scab)
 属性移除：attributeRemoved(ServletContextAttributeEvent scab)
 属性替换：attributeReplaced(ServletContextAttributeEvent scab)
 同样这里也需要一个事件参数：ServletContextAttributeEvent，通过该对象scab能取得属性的名称和内容
跟过滤器一样监听器也需要配置web.xml文件：
<listener>
 <listener-class>cn.wjr.listener.ServletContextListenerDemo</listener-class>
</listener>
向上面一样配置就可以使用了。
总结：上下文监听主要是针对容器的初始化、销毁、属性操作。
二.对Session监听：Session属于Http协议下的内容
1.HttpSessionListener接口：对Session的整体状况进行监听，其中的方法：
 Session创建：sessionCreated(HttpSessionEvent se)
 Session销毁：sessionDestroyed(HttpSessionEvent se)
 同样通过参数HttpSessionEvent对象se来取得Session对象：public HttpSession getSession()
2.HttpSessionAttributeListener接口：对Session属性进行监听：
 属性增加：attributeAdded(HttpSessionBindingEvent se)
 属性移除：attributeRemoved(HttpSessionBindingEvent se)
 属性替换：attributeReplaced(HttpSessionBindingEvent se)
 同样这里也需要一个事件参数：HttpSessionBindingEvent，通过该对象se能取得属性的名称和内容
☆注意一下Session属性的销毁：
1.时间过长会自然销毁：可以在web.xml中配置具体销毁时间：
<seesion-config>
 <session-timeout>1</session-timeout>  //表示1分钟失效
</seesion-config>
2.手动销毁：invalidate();

如何配置tomcat数据源：

首先是tomcat server.xml配置代码：
  <Context path="/test" docBase="f:/testweb/"
  debug="5" reloadable="true" crossContext="true">
 
  <Logger
className="org.apache.catalina.logger.FileLogger"
    
prefix="localhost_MysqlTest_log." suffix=".txt"
     timestamp="true"/>
    
 <Resource name="jdbc/mldn"  auth="Container"
type="javax.sql.DataSource"/>
 
 <ResourceParams name="jdbc/mldn">
  <parameter>
   <name>factory</name>
   
<value>org.apache.commons.dbcp.BasicDataSourceFactory</value>
  </parameter>
  <parameter>
   <name>maxActive</name>
   <value>100</value>
  </parameter>
  <parameter>
   <name>maxIdle</name>
   <value>30</value>
  </parameter>
  <parameter>
   <name>maxWait</name>
   <value>5000</value>
  </parameter>
  <parameter>
   <name>username</name>
   <value>scott</value>
  </parameter>
  <parameter>
   <name>password</name>
   <value>tiger</value>
  </parameter>
  <parameter>
   <name>driverClassName</name>
   <value>oracle.jdbc.driver.OracleDriver</value>
  </parameter>
  <parameter>
   <name>url</name>
   <value>jdbc:oracle:thin:@localhost:1521:MLDN</value>
  </parameter>
   </ResourceParams>
 </Context>

然后是Web应用文件的web.xml中对数据源JNDI的引用，代码如下：

<webapp>
 <resource-ref>
  <description>DB connection<description/>
  <res-ref-name>jdbc/mldn</res-ref-name>
  <res-type>javax.sql.DataSource</res-type>
  <res-auth>Container</res-auth>
 </resource-ref>
</webapp>

最后就是jsp页面使用数据源了：

<%@ page import="java.sql.*"%>
<%@ page import="javax.sql.*"%>
<%@ page import="javax.naming.*"%>
<%!
 final String JNDINAME = "java:comp/env/jdbc/mldn" ;
%>
<%
 Connection conn = null ;
 try
 {
  // 初始化查找命名空间
  Context ctx = new InitialContext() ;
  // 找到DataSource
  DataSource ds = (DataSource)ctx.lookup(JNDINAME) ;
  conn = ds.getConnection() ;
 }
 catch(Exception e)
 {
  System.out.println(e) ;
 }
%>
<%=conn%>
<%
 // 将连接重新放回到池中
 conn.close() ;
%>
结束。