Java Web开发笔记

一、泛型：
为了避免数据类型的安全隐患，在定义类或方法以及接口时，指定一个类型参数，在类实例化或者接口被类实现时用实际的类型对参数类型进行替换，
替换后所有的参数类型必须是替换类型，这样解决问题。
定义语法：
　　在定义类时指定泛型：类中的数据成员，成员方法的返回值类型、参数类型都可以使用类型参数T,在类实例化时指定实际类型.类型参数在实例化时必须是类类型。
class AAAA<T>
{
   T obj1;
   T obj2;
   T getObj1(){
      return obj1;
   }
   void setObj1(T obj){
     this.obj1 = obj;
   }

实例化
AAAA<Integer> aaaa = new AAAA<Integer>(1,2);
AAAA<String> aaaa = new AAAA<String>("aaaa","bbbb");

泛型接口：定义接口时指定类型参数，类实际该接口时用实际类型进行替换。
public interface Compare<T>
{
  public int compare(T obj);
}

public class Person implements Compare<Person>{

   public int compare(Person obj){

   }
}

Compare<Person> c1 = new Person();/泛型接口。经常用到。注意尖括号中的内容，和后面的类。
List<Person> list = new ArrayList<Person>()//
受限泛型：
public class ObjectGroup<T extends Number>;//传入的实际参数必须是Number的子类。泛型类型的实际类型可以是类也可以是接口。

二、集合框架
集合：java中装对象的容器。web开发中页面与页面之间传递多个对象时，可以用集合来装对象。

Vector:代表线性结构，特点：元素有序存储，支持下标访问，元素在容器中可重复出现。
Dictionary:代表映射结构：特点：键值对，无序存储，支持键访问，不可重复。值可以重复，键不可以重复。
容量：存储空间的大小StringBuffer.capacity();
长度：实际存储的大小StringBuffer.length();
集合和容器都在util包中
Enumeration:是一个迭代器，定义了两个方法
bool hasMoreElements();
E nextElement();
Vector:
    elementCount：对象中的组件数
    capacityIncrement:步长
构造函数：Vector(),构造一个空向量，内部数据数组大小为１０。
Vector<Integer> v= new Vector<Integer>(20);//初始容量为２０。
v.add(E);//加到最后
v.add(index,E);加到指定位置。可以通过Emumeration来遍历。
Emumeration<Integer> e = v.elements();
while(e.hasMoreElement()){
  Integer i = e.nextElement();
  System.out.println(i);
}
java2中
　　1.线性表结构：
　　List接口:所实现类主要有ArrayList,Vector,LinkedList。元素有序存储，支持下标访问，值可以重复。
    add(E o);
    clear();
    contains(object o);
    Iterator<E> iterator();返回以迭代器
　　用Vector和ArrayList的居多。
　　List<Integer> list= new ArrayList<Integer>();
　　list.add(1);
    list.add(2);
    list.add(3);
    Iterator<Integer> it = list.iterator();//单向迭代器
    while(it.hasNext()){
       System.out.println(it.next());
    }
    ArrayList:底层以数组来实现的，适合反复遍历，不适合频繁的元素插入和删除操作，动态的增减大小，长度超过开始长度时，
   自动增加原来的50%,删除对象时自动减小。其父类AbstractList实现了Iterator
   双向迭代器：ListIterator.有hasNext(),hasPrevious();通过next(),previous()来取。
　　ArrayList如果要通过Enumeration来遍历，可以先转换成Vector.
    Vector:方法都是线程安全的，底层也是通过数组实现的，空间是倍增的。ArrayList是非线程安全的
　　LinkedList:底层是通过链表实现的。第一个结点中包含了下一个结点的地址。适合大量的添加和删除操作。
2.Set集结构，元素无序存储，添加和遍历的顺序可能不一致，元素的值不能重复。也是接口，其父接口是Collection,Iterable<E>
  HashSet():默认初始容量是16
  Set<Integer> set = new HashSet<Integer>();
  set.add(1);
  set.add(2);
  Iterator<Integer>it=set.iterator();
  while(it.hasNext()){
    system.out.println(it.next());
  }
  TreeSet要求添加的类必须实现比较器接口，否则抛异常。
  3、Map映射结构，存储的对象是键值对，可以存储键值为null的对象。如果试图存储键相同的键值对对象，用新值替换旧值。然后返回旧值。
      对Map集合遍历有两种方法：
      1是获得所有键值对的的键的Set集
  Properties属性表结构，要求键和值必须是String类型，可以通过普通的map遍历方式进行遍历，软编码技术，实现读写XML文件。实现读写属性表文件。
Properties();有getProperty(String key),getProperty(String ke,String defaultValue);load(InputStream inStream);setProperty(String key,String value);
Properties p= new Properties();
p.setProperty("username","scott");
p.setProperty("password","tiger");
//p.setProperty("url","");
String username=p.getProperty("username");
p.store(new FileOutputStream("d:\\scottinfo.pro"),"scott info");
p.storeToXML(new FileOutputStream("d:\\scottinfo.xml"),"scott info"));

 

TreeMap,
HashMap,
HashTable。

HashMap<String,Integer> map= new HashMap<String,Integer>();
map.put("a",97);
map.put("b",98);
Set<String> set = map.keySet();
Iterator<Stirng> it = set.iterator();
while(it.hasNext()){
  Stirng key=it.next();
  Integer value=map.get(key);
  }

2是获得键值对的Set集
//获得建值对的Set集
Map.Entry<K,V>内部接口.返回键值对的对象。
Set<Map.Entry<String,Integer>> set = map.entrySet();
Iterator<Map.Entry<String,Integer>> it1 = set.iterator();
while(it1.hasNext()){
   Map.Entry<String,Integer> entry = it1.next();
   System.out.println(entry.getKey()+-----+entry.getValue());
}
三、JDBC

JDBC:是Java为了支持SQL功能而提供的与数据库相连接的用户接口。它包括由Java语言书写的类和接口，这些类和接口都是独立于DBMS的。
Oracle:ojdbc14.jar.从oracle安装目录下找到ojdbc14.jar,拷到工程环境中的Refernced Libraries目录下。选中该jar包，右键build path.
JDBC类的相关类多在java.sql包中
DriverManager类调用Connection实现接口或者Driver接口，获取连接数据库的实现类。
CallableStatement用来发送存储过程的SQL语句的容器。它继承自PrepareStatement,prepareStatement继承自Statement.
ResultSet接口用来接收结果集的
JDBC编程步骤：1与数据库建立连接2向数据库发送SQL语句3处理数据库返回结果。
具体分为5步：
1.向驱动程序管理器加载、注册驱动程序。有两种方法实现，一是使用DriverManager类实现对驱动程序的注册，第二种使用Class.forName()方法实现驱动程序的注册。
通过getDriver()方法获得Driver接口的实例。
Driver d=DriverManager.getDriver("jdbc:odbc:school");
通过registerDriver(Driver driver)注册驱动程序。
DriverManager.registerDriver(d);
抛SQLException异常。
第二种：
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//可能找不到类，参数是类的全路径。
抛类找不到异常ClassNotFoundException
2、获得特定的数据库连接，使用DriverManager类的静态方法getconnectio('URL');
conn = DriverManager.getConnection("jdbc:odbc:school");
if(conn==null){
  }
3、创建SQL语句的容器，SQL语句的容器的功能是可以发送SQL语句，并将数据库服务器返回的信息得到。
有三种SQL语句容器，分别是Statement,PreparedStatement,CallableStatement.
Connection接口有close()关闭方法，createStatement();创建SQL语句的容器。
Statement stmt;
ResultSet rs;
stmt = conn.createStatement();
查询语句返回结果集，增删改返回影响的行数。
String sql="select * from student";
发送查询语句，可能会有结果集返回，返回结果集是ResultSet接口类型的容器。
4、处理结果集
rs = stmt.executeQuery(sql);//增删改都是executeUpdate(sql);
while(rs.next()){
   int stuid = rs.getInt(1);
   String stuname = rs.getString(2);
   String stusex = rs.getString(3);
   Date birthday = rs.getDate(4);
   //格式化日期
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
   String birt = sdf.format(birthday);
}
rs.getInt(1)或者rs.getInt("stuid");
getDate(int columnIndex);
getDate(String columnName);
5、关闭连接，一般放在finally里
if(rs!=null){
  rs.close();
  }if(stmt!=null){
     stmt.close();
}if(conn!=null){
   conn.close();
}
结果集当不滚动时，只能从上到下遍历。滚动结果集可以从下到上遍历。就用带参数的SQL语句容器。resultSetType,resultSetConcurrency.
可以使用rs.last(),rs.afterlast(),rs.first(),rs.beforefirst().

mysql数据库分页使用limit 1,2就是从查出的数据中从索引为1的开始取，取2个。

oracle数据库分页使用一个虚拟列rownum

select * from (select e.*,rownum r from emp e)e1 where e1.r between ? and ?;
prepareStatement(sql);
SQL中的?表示占位符，PreparedStatement支持占位符，通过set方法设置占位符的值。
pstmt.setInt(1,1);表示语句中的第一个占位符值是1.
CallableStatement接口：是调用数据库存储过程或者函数的对象，可以有占位符，占位符可以是in参数也可以是out参数。好处是给用户调用存储过程的权限，不给其表的权限
。提高数据安全性，而执行效率高。
String sql="{存储过程名(?,?,?)}";或者有返回值时，sql="{?=存储过程名(?,?,?)}";
CallableStatement cs = conn.prepareCall(sql);
还要对输入输出参数进行设置
如果是in参数，用setXXXX方法设置占位符的值。
对输出参数设置
void registerOutParameter(int parameterIndex,int sqlType) throws SQLException
第一个参数代表是第几个占位符，第二个参数是返回值类型对应于Types类中的静态常量如Type.INTEGER.还可以使用另一个同名重载的方法，
多一个参数int scale用来限制小数点右边出现的位数。
执行存储过程使用executeXXXX方法。如果有返回结果出现，调用getXXXX方法获得输出参数的值。
oracle默认端口是1521.

四、Tomcat
tomcat默认端口是8080.
一个IP地址的端口可以用65536个.1024之后的我们可以用。之前的被操作系统占用了。
tomcat是一个WEB服务器软件，能够接收HTTP请求，并且可以构造一个HTTP返回。
配置Tomcat_HOME:
在系统变量增加一个tomcat_home,它的值为TOMCAT的安装主目录，注意不是BiN。还要配path,jdk,classpath.Myeclipse不配也可以，但eclipse必须配。
Tomcat主目录中的conf下的Server.xml用来配置tomcat的服务信息的，主配置文件。服务的名字是Catalina,Connector配置端口，最大线程。连接时间，引擎。
context.xml配置tomcat数据库连接池可以在这里。配置环境的。
tomcat-users.xml配置tomcat用户的。
web.xml用来保存Web应用程序默认配置。Servlet默认配置。映射，过滤器。默认的主页面。
webapp文件夹用来存放WEB站点的目录，发布的WEB程序都放在这里。
jsp的字节码文件都将放到work目录的catalina下。

五、Sevlet
Servlet:是一个运行在服务器端的java类，它可以获得客户的请求，并对请求做出响应。
任何Servlet类都直接或间接实现了javax.servlet.Servlet接口，在这个接口中只定义了5个方法，init,getServletConfig,service,getServletInfo,destroy.
javax.servlet.http.HttpServlet里面提供了针对于http协议使用的方法。所以一个Servlet类，应该从HttpServlet类继承。并实现它的doget或dopost方法。
Servlet是单进程多线程的。
Servlet类写好后一定要在web配置文件中进行注册。
客户端发送一个请求后，请求到达服务器，服务器解析请求，如果请求的是Html，就把html生成数据包，以流的形式反馈给客户端，
客户端浏览器会解析html并显示出来。如果请求是一个Servlet映射，就去web.xml
中查找servlet-mapping的url-pattern中查找。查找到servlet-name后，就去找对应的类。并且加载类。
然后再根据请求是get或者post形式，调用Servlet类中的doget或doPost方法。基于URL的请求。
request和response：
当客户端请求Servlet时，在运行servlet之前会创建两个对象，request是用来封装客户的请求，response是用来处理请求之后负责响应的对象，
通过这个对象获得一个输出流对象，通过输出流向客户端发送一个Html
文档的内容。客户端浏览器收到响应的内容后进行解析。
请求一个Servlet过程:1.创建一个Web工程，生成一个Class继承自HttpServlet或者生成一个Servlet类。实现doget或dopost方法。
在web.xml中配一个servletname关联到这个Servlet类，再配一个url-mapping映射到这个servletname.
Servlet字节码文件会在第一次请求的时候会创建一个实例，如果再有客户端请求将不会再次创建新的实例，只会开辟新的线程。
Servlet的生命周期：即下面三个方法
init();在第一次创建后被请求或者是修改后第一次被请求时调用此方法，实例化Servlet,在实例化之前会创建两个接口类型的对象HttpServletRequest和HttpServletResponse对象，该方法只被调用一次。

service();根据请求的类型，(post/get)，由service()调用doPost()或者是doGet(),处理请求并响应。
destroy();销毁Service实例，由服务器决定。
HttpSevlet是单例模式，只有一个实例，处理多个客户的请求。无状态连接即是服务器把请求响应到客户端后马上断开。有状态连接如FTP协议的连接。服务器端和客户端连接后请求完成一直是连接的。
除了在Form的method中设为post方法调用doPost方法外，其它的比如通过url等都是get方法
改工程名字通过右键工程，property,myeclipse,web,context-root
在获得客户端提交的信息或者是响应之前设置编码格式，防止乱码发生。
在servlet的doPost中通过response.setCharacterEncoding("UTF-8");
request.setCharacterEncoding("UTF-8");
String username = request.getParameter("username");
String password = request.getParameter("password");
Servlet基本功能：
1,接受客户端的请求，并产生响应结果返回给客户端。要注意HttpServletRequest和HttpServletResponse两个接口类型的实例的使用。
request获取客户端表单数据的方法是getParameter(String name);根据name取到值。String[]类型的结果被返回，用getParameterValues(String name)返回数组，可以获得表单数据，像复选框等。
response将信息响应回客户端。
2.通过request进行转发实现组件跳转。通过调用getRequestDispatcher(String path)获得RequestDispatcher类型的转发的实例。再通过这个转发的实例调用forward()方法，转发是服务器端跳转，对客户端来说
是同一个请求，可以通过request调用setAttribute(String key,Objct value);将跳转过程中需要传递的数据注入到request中，到达目的地后可以通过request.getAttribute(String key)将这个值取出。
把要传递的内容保存在request中。
request.setAttribute("user",user);
通过request实现转发，服务器端的跳转，对于客户端是同一个请求。转发后在新的组件中通过(User)request.getAttribute("user");获得传过来的值。
request.getRequestDispatcher("display_update").forward(request,response);//display_update是映射，是servlet的映射。
//其它代码不能被执行，因为转发后不要再写代码。
3.生成动态页面

解决乱码方法：1.response.setContentType("text/html;charset=utf-8");2.response.setCharacterEncodeing("utf-8");
重定向：客户端的两个请求，地址栏的URL会有变化。这个是在客户端的跳转。比如请求A到达服务器后，服务器响应后返回客户端让请求B，客户端自动又发送了一个请求B的动作，服务器把请求B后的响应结果返回给客户端。
response.sendRedirect("servlet2");//重定向
注意：转发时可以把要传的值放到request中，并在转发目的中取到。而重定向不行，因为它又发了一个新的请求，在新的请求中并未传过来。如果想在重定向的时候传递值那就用ServletContext吧。
ServletContext context = this.getServletContext();
context.setAttribute("user",username);
context.setAttribute("password",password);

在重定向的目的Servlet类的doGet或doPost方法中通过String username = (String)context.getAttribute("user");
String password= (String)context.getAttribute("password");
ServletContext在Web开发中是全局变量。可以用来取而页面的访问量
ServletContext还可以在Web初始化的时候取设好的参数值。通过在Web.xml中进行配置。
<context-param>
  <param-name>user</param-name>
  <param-value>scott</param-value>
</context-param>
上面设好后通过String user=context.getInitParameter("user");这样就能取到user的初始化密码了。
context.getRealPath("servlet1");取得绝对路径。
ServletConfig对象是每个Servlet自己独有的对象，可以在web.xml中相应的Servlet中进行配置。
<init-param>
  <param-name>user</param-name>
  <param-value>scott</param-value>
</init-param>
ServletConfig config = this.getServletConfig();
String username1 = config.getInitParameter("user");
session是使用的比较广泛的会话跟踪技术，服务器会用每一个客户端在服务器上开辟一块内存，每块内存有自己的session的ID,不同的session的ID是不同的。响应的时候会把session的ID返回给客户端。
再请求时会在把session的ID放在头文件里发送给服务器。系统会自动把session存到客户端的会话级cookie中。这个cookie的名字就是jsessionid.
HttpSession session = request.getSession();

Servlet的功能：
1.生成动态页面
2.获得表单数据
3.实现转发或重定向
请求Sevlet的方式：
1.action="servlet"
2.在地址栏中直接请求
3.转发或者重定向一个servlet映射。
4.超链接中<a href="servlet1"></a>直接写servlet的名字就行。分页的时候经常用
六、JSP:
本质上是开发Servlet的另一外种形式，它允许java和html代码混合使用，页面中静态的部分直接写html代码，而动态的部分用java来写，可以快捷的开发出web应用的视图。
Web容器管理JSP页面的生命周期主要分成两个阶段：转换阶段和执行阶段。
第一次请求JSP时，JSP引擎就会将JSP转换成Servlet类(Hello_JSP.java)，并把JSP中的html转换成Servlet中的Pagecontext.out.print的形式输出。并进行编译，生一个java字节码文件。
_jspInit,_jspService,_jspDestroy.再次请求这个JSP就不会再转换了，而直接使用第一次请求时生成的字节码文件，就跟Servlet一样的流程了。
JSP语法：
   静态代码：html,css,javascript它们也叫模板数据。
   动态代码：指令元素：<%@指令名 属性＝"值1" 属性＝"值2"%>有三个，<%@ page language="java" import="java.util.*,java.sql.*" pageEncoding="GB2312"%>
                               <%@ page import="java.text.*">//page虽然可以写多个，但是只有import属性可以使用多次。jsp页面上java.lang,javax.servlet
                               ,javax.servlet.http,javax.servlet.jsp不用导包可以直接用。
                               page指令，include指令包含一个页面和taglab指令使命jsp标签库中使用标签的指令。
如果要在jsp中编写java代码，可以在<%%>中直接写，里面可以用//和/**/进行注释java代码。jsp中表达式用<%=jsp的变量>,jsp表达式不能放在java代码中写。<%=jsp的变量>相当于<%out.print(jsp的变量);%>
JSP的内置对象有：session,request,application,response,out,可以直接在<%%>中使用。
             动作元素：
             脚本元素：
java中的字符串String email="david@qq.com"提取david用String strs[] = email.split("@");String username=strs[0];
oralce创建序列：
  create table notes(
  noteid number primary key,
  title varchar2(50),
  content varchar2(500),
  personid number,
  constraints fk_personid foreign key(personid) references person(personid)
)
  create sequence seq_personid;
  create sequence seq_noteid;
对于分页时通过href="Servlet?page=<%=p%>",在Servlet那里可以通过request.getParameter("page");
关于HTTP请求和响应：
  1、客户端浏览器向tomcat服务器发出请求，tomcat收到请求后进行分析,找到指定的站点，如果请求的是静态页面，直接找到并相应到客户端。如果是Servlet并且是第一次请求，Servlet容器加载Servlet类，创建
Servlet对象，创建HttpServletRequest和HttpServletResponse对象，根据请求的方式post/get调用doPost(HttpServletRequest request,HttpServletResponse response)或者doGet。以后再请求直接创建HttpServletRequest和
HttpServletResponse对象，不再创建Servlet类。多线程的单例模式。
如果请求的是JSP页面并且是第一次请求，首先JSP引擎对这个JSP进行转化成一个Servlet类，存放在tomcat中的work目录下，Servlet容器进行加载，创建对应的Servlet对象，根据请求的方式调用转化的类中相关的方法，因此JSP在
第一次请求时感觉稍慢。之后再请求和Servlet相同。
  2.Servlet：运行在服务器端的一个纯java类，可以创建动态页面；可以接受客户端的请求；产生响应信息；可以实现组件之间的跳转；可以对客户端状态进行跟踪(a.URL重写(键值跟踪)b.隐藏表单域(多次请求是不是同一个)c.Cookie
(两周内自动登录)d.Session(会话，当服务器和客户端建立连接后直到客户端浏览器关闭，这就是一个会话。当客户端和服务器建立连接后，服务器将为这个客户端开辟一块空间，并对这个空间用一个ID来命名，这个ID就叫sessionID,
这块空间称为Session.这个ID会通过响应流驻留到客户端的Cookie中，当下一次请求时首先会读取Cookie，会有一个上一次请求时的一个Sessionid(J通过SESSIONID键找到Sessionid值)，再通过这个值就能找到服务器上的对应Sessoinid的内存空间).
通过session实现购物车。
HttpSession session = request.getSession();
String sessionID = session.getId();
Cookie []cookies = request.getCookies();
if(cookies!=null){
  for(Cookie c:cookies){
    String key = c.getName();
    if(key.equals("JSESSIONID")){
     out.println("请求信息中的sessionid"+c.getValue);
}
}
}
3.JSP：JavaServe Page
  1.语法
    编写Java代码
    <%
    %>
    Jsp表达式
    <%=express%>
    JSP注释
    <%--
    --%>
  2.指令：<%@page import="" language="java" errorPage=""%>关于导包，除了java.lang,javax.servelet,javax.servlet.http,javax.servlet.jsp包在jsp中不用导可以直接用。
          <%@include file=""%>静态包含，被包含的资源和当前页面共同组成一个被转换的Servlet
          <%@tablab%>
  3.内置对象：与范围有关的：page,request,Session,aplication.其他的内置对象：exception,out,config,pageContext,response.
JSP的动作标签：JSP的动作元素为请求处理阶段提供信息。JSP2.0规范中一共定义了20个动作元素。这些动作元素在JSP转换为Servlet过程中将用固定的一段Java代码来替换。
<jsp:include>包含且是动态包含。包含的页和被包含的页被转换为两个不同的Servlet。<jsp:include page="jsp文件的path" flush=true|false><jsp:param name=参数名 value=参数值/></jsp:include>
在被包含页面可以把中间的参数取到。<jsp:include page="jsp2.jsp"></jsp:include>编译成两个jsp,它是动态包含，中的参数在被含页用request.getParameter("name");取。<%@include file="jsp3.jsp%>合为一个jsp.它是静态包含。
<jsp:forward><jsp:param name="参数" value="值"></jsp:forward>请求转发给另外一个资源。和RequestDispatcher.forward功能相同。jsp也是servlet引擎，同样可以提交Action的目的。get不能超过2K.
javabean的编码规则：数据成员私有化，\  <提供公共的访问者方法。setXXX,getXXX();<jsp:userBean id="p" class="vo.Person"><jsp:setProperty property="pid" name="p" value="100"/></jsp:userBean>//创建对象 相当于Person p1 = new Person();
<jsp:useBean id="p1" class="vo.Person" scope="session">或者request找。
<jsp:getPropery property="pid" name="userid"/>
</jsp>
新的页
<jsp:useBean id="p" class="vo.Person" scope="page"></jsp:useBean>
<jsp:setProperty property="pid",name="p" param="userid"/>//会从下面直接取值。
页中有<form name="form1"><input type="text" name="userid"/></form>
如果action没有指定默认提交到本页。不设action点提交，表单中的值就会到上面的bean中的属性中去。javaBean中的属性的名字必须和表单的输入签的name必须一致。否则报错。如果javaBean不想一个个的都对应着去写，
也可以使用<jsp:setProperty property="*" name="p"></jsp:setProperty>通过表单元素来赋值。也可以直接赋值。
javaweb中异常的处理形式两种：声明式的异常处理，在web.xml中使用<error-page><error-code>404</error-code><location>/err.jsp</location></erro-page> 设完后在err.jsp页面的@page中设定isErrorPage="true".那么异常时就会自动跳到该异常页面。
                             程序式的异常处理，try catch
过滤器Filter：主要作用是用户和请求资源之间设置的一段程序，每次到达资源之前都会所有的请求都会被过滤器拦截执行一段程序然后才到达资源。中间的这段拦截程序就是过滤器。
              实现Filter：写一个类实现javax.servlet.Filter接口，然后在doFilter方法中写上对应的过滤代码，最后在web.xml文件中加上对应的注册信息。
              Filter接口：public void init(FilterConfig config);初始化方法public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)主要方法，发出请求时调用些方法。FilterChain是下一个过滤器。
在web.xml中配置过滤器：<filter><filter-name>过滤器name</filter-name><filter-class>完整的class名</filter-class></filter>
                       <filter-mapping><filter-name>过滤器名字</filter-name><url-pattern>需要过滤的资源的URL</url-pattern></filter-mapping>如果<url-patter>设置为/*,则表示过滤当前Web应用中所有资源，如果只想过滤某一个目录或某一个url也是可以的。如/session/*.
在一个web.xml中可以设置多个过滤器。
public class MyFilter implements Filter{
  public void doFilter(ServletRequest arg0,ServletResponse arg1,FilterChain arg2) throws IOException,ServletException{
    HttpServletRequest request  =(HttpServletRequest)arg0;
    String username=request.getParameter("username");
    if(username.equals("")||username.equals("zhangsan")){
      request.getRequestDispatch("err.jsp").forward(arg0,arg1);
}
    arg2.doFilter(arg0,arg1);
   }

}写完后在web.xml中配置一下。<filter><filter-name>myfilter</filter-name><filter-class>filter.MyFilter</filter-class><filter>
                            <filter-mapping><filter-name>myfilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>
删除一条纪录。删除后转到查询页。String path=response.encodeURL("show_emp?page="+curge);response.sendRedirect(path);
JSP开发的两种模型：1JSP+JavaBean技术将页面显示和业务逻辑处理分开，JSP负责调用JavaBean中的功能然后把执行结果显示在JSP页面上。
                   2MVC模型
EL表达式：语法简单，使用方便，所有EL表达式都是以${开始，以}结束。${sessionScope.user.name}相当于取session中取的user类的name.
在EL语言中，与范围有关的四个对象。page,request,session,application.
EL中提供了.和[]两种操作符来存取数据。${sessionScope.user.username}与${sessionScopte["user"]["name"]}.注意中括号里面是双引号。用点的地方都可以用中括号。
有小数点，下划线等特殊字符的只能用中括号。${pageScope.user}${requestScope .user}${sessionScope.user}${applicationScope.user}
算术运算符：+:${2+4}-:${3-4}*:{3*4}/:${4/3}div:${4 div 3}mode:${4 mode 3}%:${4%3}
关系运算符：>:${3>4}gt:${4 gt 3}
逻辑运算符：&& and || or ! not
param：相当于request.getParameter方法，如果参数不存在，返回空字符串。paramValues相当于request.getParameterValues方法，返回一个字符串数组，参数不存在，返回空字符串。
JSTL:jsp标准标签库是一个开源的标签库，可以取代传统的在页面中嵌入java程序的做法，提高程序的可读性及维护性。
需要把jstl-1.2.jar文件拷到web-inf/lib目录中。还需要在jsp页面中加入taglib指令。<%@taglib uri="标签库URI" prefix="标签前缀"%>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>//标签库很多，用的较多的是core核心标签库c。还有I18N标签库，sql标签库sql，xml标签库x，函数标签库fn等。
<c:out value="${user.userid}" default="0" escapeXml="false"></c:out>其中的value支持EL语言，是需要显示的值。default,如果Value为null，则显示default值。
<c:if test="${param.username=='king'}" var="result" scope="request">
处理代码
</c:if>
<c:choose>
  <c:when test="${param.score>=85}">
  优秀
  </c:when>
  <c:otherwise>
  </c:otherwise>
</c:choose>
<c:forEach>//为循环控制标签，可以遍历集合，组合的元素。可以用于计数运算。
</c:forEach>
<c:forEach begin="0" items="${sessionScope.list}" step="1" var="str" varStatus="status">
<c:out value="${str}"></c:out>
七、AJAX:
   使用ajax技术需要一个重要的对象XMLHttpRequest,针对于不同的浏览器初始化不同，比如使用IE或者火狐，该对象可以实现数据的异步提交，和获得服务器的响应内容text,xml.
   var xhr = null;
   //如果是MS的，完成对象的初始化
   function ajaxsubmit(){
       if(window.ActiveXObject){
       xhr = new ActiveXObject("Microsoft.XMLHTTP");
         }
       if(window.XMLHttpRequest){
        xhr = new XMLHttpRequest();
       //通过xhr打开一个和服务器的链接，这个链接可以是一个servlet,可以是一个jsp.
       xhr.open("GET","servlet1",true);//提交方式，提交目的，是否异步提交
       //设置一下当服务器的响应回来后的处理函数。
       xhr.onreadystatechange=fun1;
       //发送请求
       xhr.send(null);
         }
      function fun1(){
       //readyState:1:发送请求，2请求正在处理，3处理完毕，准备返回，请求处理完毕，并且已经返回
       if(xhr.readyState==4){
          //status:返回的状态码，200成功
        if(xhr.status==200){
       //alert("服务器响应回来的信息是："+xhr.responseText);
          document.getElementByID("ajax").innerHTML=xhr.responseText;
         var pElements = document.getElementsByTagName("p");
         for(var i=0;i<pElements.length;i++)
          {
             pElements[i].innerHTML="sdfghjk";
          }
        }
       }
      }
   }

八、Struts1:
  一框架的基本概念：框架是指一组可以重用的软件包按照某种规范组织到起，提高开发效率，在框架中通常使用一些XML文件对使用的组件进行配置。
  1.Struts分为Struts1.x和Sturs2.x。Struts1是对JspServlet的整合，采用MVC模式的一个开源框架，Struts2是采用了著名的开源框架WebWork。
  2.Hibernate：著名的ORM开源框架
  3.Spring通过控制反转和面向切面实现了很好的降低组件之间的耦合，并实现了对事务的控制管理。控制反转：在平时我们创建对象的时候，需要调用构造方法，创建对象的主动权在在程序里。控制反转就是创建对象的主动权
  不在程序中。而在Spring框架中。我们可以拿来用。依赖注入：就是调用Set方法把一些值注入到对象当中。只需配置即可。面向切面：在实现一个事务的时候可能包括和许多的数据处理动作，使用AOP面向切面对事务进行管理。
  二Struts1:是一个基于java servlet/jsp技术的MVC应用框架，驻留WEB层，它把Servlet,jsp,自定义标签和信息资源整合到统一的框架中，开发人员利用其开发时不用再自己编码实现全套MVC模式，极大的节省了时间。
    jsp发送请求到核心控制器，核心控制器再转发给业务逻辑控制器。
    客户端浏览器发送Http请求到ActionServlet，ActionServlet根据请求填充FormBean即ActionForm。然后发送请求到对应的业务逻辑控制器。
    1.加载struts1的jar包，MyEclipe已经集成好了，可以直接用，选择Servlet的时候，如果带.do的就在调用servlet的时候加上.do。但是eclipse没有，需要到官网找到下载后加载。Struts1的核心控制文件是Struts-Config.xml,
      在Web-inf下。通过MyClipse的自带包创建struts1后会在web.xml中生成一些内容。核心控制器和核心配置文件，及映射格式。
<servlet>
    <servlet-name>action</servlet-name>
    <servlet-class>org.apache.struts.action.ActionServlet</servlet-class>
    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>
    <init-param>
      <param-name>debug</param-name>
      <param-value>3</param-value>
    </init-param>
    <init-param>
      <param-name>detail</param-name>
      <param-value>3</param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
  </servlet>
  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>
然后创建一个LoginAction继承自Action后，实现它的execute方法。
然后创建一个LoginForm继承自ActionForm类。ActionForm中增加成员并实现setget方法。成员应和提交过来的客户端Form表单中的一一对应。名字要相同。在ActionForm类中还有两个方法reset()用来设置表单元素的初始值。
validate用来实现客户端的服务前端验证。该方法返回null或者是返回的错误集合中没有元素的话，请求将会到达action.
然后编辑struts-config.xml配置文件。里面的<data-sources/>配置数据库连接池获得连接。<form-bean name="loginForm" type="com.ts.form.LoginForm"/>
<action-mappings>
  <action path="/login"
   attribute="loginForm"
   name="loginForm"//跟上面的form-bean中的name相同。
   scope="request"//上面创建的对象所适用的范围，只有request和session'
   type="com.ts.action.LoginAction"//配置Action的类
   >
   <forward name="success" path="/loginSuc.jsp"></forward>
   <forward name="failure" path="/loginfail.jsp"></forward>
  </action>
</action-mapping>
 1.添加Struts1.x的jar包和相关文档2.创建登录页面3.创建LoginAction业务逻辑控制器，继承自Action类。4.创建LoginForm继承自ActionForm。定义和表单名字完全一样的属性，并提供对应的SetGet方法，可以重写reset方法和
  validate()方法。5.对Struts-config.xml进行配置，这个地方是个重点，也是难点，首先配置<form-beans>看这个名字就知道是个集合，里面可以写好多个<form-bean>,
  在<form-bean name="loginForm" type="com.ts.form.LoginForm">通过name属性指定一个FormBean的名字，以便和下面的<action-mappings>中的<action>进行对应。其次要配置<action-mappings>中的<action>和上面的<form-beans>中的某个<from-bean>进行对应。
  <action path="/login" attribute="loginForm" name="loginForm" scope="request" type="com.ts.action.LoginAction">
  这里的path是/加上映射名。如果在struts1工程创建时指定了*.do,那么在视图页面的action就是"映射名.do"，name要和上面<from-beans>中的<form-bean>中的name对应。scope表示使用的有效范围，只有request和session两种。type就是这个具体的业务逻辑类的全路径。
  还要在<action>和</action>中配置跳转的路径。当该业务逻辑控制器类的execute方法返回什么字符串，跳到相应的页面。<forward name="success" path="/loginSuc.jsp"></forward> 
a.配置form-bean b.配置action。
6.执行过程：首先AcionServlet获得客户端的请求，接着读取Struts-config.xml配置文件，创建相关对象，首先调用FormBean的无参构造方法创建FormBean对象，
  并将客户端表单数据的内容填充到formbean对象中。接下来如果Action对象不存在，创建Action对象，将FormBean对象传给Action的execute方法，在execute方法中调用模型层完成业务逻辑并选择视图响应到客户端。
创建FormBean,Action都是RequestProcessor类来完成的。ActionServlet接收到一个HTTP请求，无论是GET还是Post方法，ActionServlet的Process()方法都会被调用。在这个方法中，主要目的是调用RequestProcessor类的process()方法，这个方法完成读取配置文件，创建FormBean，创建Action，填充FormBean。减轻了ActionServlet的负担。
struts1有html标签，要通过<%@taglib uri=""%>进行引用。还有bean标签和logic标签。
struts1中Action都是继承自抽象的Action类的，是和HttpServlet耦合在一起的。我们还要重写一个execute方法。struts1中的action和普通的servlet一样，是单实例多线程的，使用不当会造成线程安全问题。
struts2中的Action没有限制，每一个类都可以做为Action，只要提供Execute方法。脱离了Servlet容器的限制。struts2中的action是多实例的，为每一个客户端提供一个action的实例。对servlet的依赖降到了最低。

九、Struts2:
    最基本jar包：commons-logging-1.0.4,freemarker,ognl,struts2-core,xwork.
    核心配置文件是struts.xml,放在src下面，。这个文件的头信息可以从core包里的struts-default.xml取。主节点是<struts></struts>
    在web.xml中配置一个过滤器，核心过滤器,必须的过滤器。core包里的FilterDispatcher.
   <filter><filter-name>filter</filter-name><filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class></filter>
   <filter-mapping><filter-name>filter</filter-name><url-pattern>/*</url-pattern></filter-mapping>
   创建表单，创建Action,实现getset方法，且属性和表单里的要一致便于接收表单数据，实现execute方法，返回String类型。
   配置Struts.xml。如果没有提示，windows-preferece-file and editors-xml catalog-Add-Key Type=URI,location指向解压后的核心包中的struts-2.0.dtd。Key的值从struts-2.0.dtd中找那个网址。
   <struts>
      <package name="struts2" extends="struts-default"></package>//继承这个包之后，许多配置我们就不用配置了，struts-default已经帮我们配置好了。
      <action name="login" class="com.ts.action.LoginAction">//配置Action名字和对应类的全路径。这里配login,前台表单的提交Action是login.action.
         <result name="LoginSuc">/loginSuc.jsp</result>//这里配置当前Action的跳转，当前Action的execute方法返回"LoginSuc"则跳转到/loginSuc.jsp.
         <result name="LoginFail">/loginFail.jsp</result>  
   </struts>
创建struts2工程的基本步骤
1·创建web工程
2.将Struts2工程所需要的核心的5个jar包拷贝到工程的WEB-INF下的lib目录中
3.在src目录下创建struts.xml配置文件，该文件是struts2工程的主要配置文件，将核心包下的struts-default.xml中的头信息拷贝
到该文件中，或者到struts2的源码的实例工程中拷贝该文件
4.在web.xml中配置核心过滤器（拦截器）配置如下：
 <filter>
  <filter-name>filter</filter-name>
  <filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
 </filter>
 <filter-mapping>
  <filter-name>filter</filter-name>
  <url-pattern>/*</url-pattern>
 </filter-mapping>
5.创建前台页面 form标记的action属性值默认情况下必须带后缀.action
6.创建action类，并在类中添加对应的前台页面中的和表单名字相同的属性，并提供set和get方法，还要定义一个execute()方法，该
方法是public ,返回值类型是String
7.在struts.xml中进行action的配置
  <package name="struts2" extgends="struts-default">
    <action name="login" class="com.ts.action.LoginAction">
      <result name="success">/loginSuc.jsp</result>
      <result name="failure">/loginFail.jsp</result>
    </action>
  </package>
 8.配置Tomcat数据库连接池
struts2继承ActionSupport后，就能够使用内置的action返回常量。如SUCCESS,ERROR，INPUT。还可以通过在execute中使用this.addFieldError("username", "username is error");把错误信息发到客户端上显示出来。
还有一个validate()进行表单数据验证，重载此方法，并写代码对提交的表单进行验证。
struts2中有一个标签：s标签。标签文件在core包的meta-inf下面，有一个struts-tags.tld的文件。从中找到标签uri和short-name
 <short-name>s</short-name>
  <uri>/struts-tags</uri>
  加到表单页面中的taglib中去。把表单中的属性都换成s标签的，然后在execute中
this.addFieldError("username", "username is error");两个参数，属性名和提示信息。这个的好处就是不用做任何配置。

struts2中的领域模型：前面的表单属性都是直接定义在ACtion中的，并提供getset方法。而通过使用模型模型呢，可以把属性数据封装到完整的类中。就是单独定义一个类用来存表单的属性值，并提供getset方法。然后在
Action中定义一个领域模型的属性来接收领域类的值，并提供setget方法。使用领域模型方法时表单那里也要写上Action中属性对象的属性值。如user.username作为属性的name.
通过领域对象来获得表单数据：
  1.定义独立的一个类（领域对象），该类中的属性和表单中的属性一致，并提供setget方法
  2.在Action中通过这个类定义对象，初始值为null，并提供setget方法
  3.表单名称需要加action中定义的领域对象来引导如：user.username.在其它页面通过值栈取属性值时也要用领域对象名引导
通过模型驱动来记录表单数据：
  1.定义独立的一个类（领域对象），该类中的属性和表单中的属性一致，并提供setget方法
  2.Action类需要实现ModelDriven接口，泛型采用领域对象的类型，在Action类中通过无参构造方法创建领域对象，实现抽象方法。
 //模型驱动的方法
public class LoginAction1 extends ActionSupport implements ModelDriven<User>{
 User user= new User();

 public String execute(){
  if (("zhangsan").equals(user.getUsername())&&("123456").equals(user.getPassword())){
   return SUCCESS;
  }
  this.addFieldError("user.username", "username is error");
  return ERROR;
 }
 public User getModel() {
  // TODO Auto-generated method stub
  return user;
 }

}
  3.表单名称无需领域对象引导，在其他页面通过值栈取属性值时也无需用领域对象名引导。
Struts2简单Demo的运行过程：
  1.用户提交请求
  2.请求将被FilterDispatcher过滤
  3.FilterDispatcher调用ActionMapper
  4.FilterDispatcher将请求处理交给ActionProxy
struts配置的编码格式是UTF-8 
Struts2中的配置文件：
  web.xml:是web工程的配置文件，在该文件中配置过滤器，不同版本的过滤器可能不同。
  Struts.xml:是Struts2的核心配置文件，<constant>配置属性，<include>把xml分开存储时，用这个包含进来。package包文件，可以继承那些已经配置好了某些内容的包。包的abstract属性设为true后，里面就不能配置Action属性。
  struts-default.xml:struts框架默认的主配置文件，其中的struts-default包中的配置为核心的默认配置
  struts.properties:默认的属性配置
  struts.2.0.dtd:struts2框架配置文件的dtd文档规范定义
  struts-tags.tld：struts2的标签配置文件
  1）默认action:当请求的action不存在时，会执行默认的action,默认的action要求在所有的action之前进行配置，配置如下：
   <default-action-ref name="error"/>
  <action name="error">
   <result>/error.jsp</result>
  </action>
  拦截器：在Struts.xml中的package里的action的前面可以配置拦截器。当包中定义了拦截器，继承自包中的拦截器都失效。
  <interceptors>
    <interceptor name="timer" class="com.opensymphony.xwork2.interceptor.TimerInterceptor"/>
    <interceptor name=Iors>
  定义完可以在<action>中进行指定该action使用哪个或哪些。
  例如在<result>前加<interceptor-ref name="timer"></interceptor-ref><interceptor-ref name="param"></interceptor-ref>
 还可以把拦截器定义成拦截器栈的形式，在拦截器栈中再定义多个拦截器，然后在action中引用这个拦截器栈。
Action的配置：
  1.分发action:在配置文件中指定action中被明确调用的方法，参照配置文档
  2.动态方法调用和普通的action配置相同，在引用action时，在映射后面跟"!action"中方法的名字，在页面执行时动态的确定要调用的方法。
  3.在配置时可以使用多个通配符
  4.转发action
  当使用一个action只是实现跳转功能，可以按如下定义
  <action name="test_forward">
     <result type="dispatcher">/test_forward.jsp</result>
  </action>