精华内容
下载资源
问答
  • 64 jsp+servlet需要的全部在这了
  • 项目里要用到commons-logging。它有几个依赖,其中有一个是servlet-api-2.3.jar。现在我需要用到容器内的servlet-api的异步功能,编译的...请问哪有经验处理这样的冲突,可以屏蔽掉servlet-api-2.3.jar这个依赖
  • 求Struts2 Hibernate spring servlet 框架及说明文档。我想学习下java 三大类框架的设计,本人刚刚接触,希望各位同仁支持下。文件接收邮箱:zyq704067777@163.com QQ 704067777求一黑客师傅。愿意跟随
  • servlet

    千次阅读 2015-12-07 11:02:24
    数字,w3c定义,表web server处理请求的的状态 200 :正确 500 :系统错误 404 :依据地址找不到对应的资源 b,若干消息头 服务器也可以发送一些消息头给浏览器 比如“context-type”消息头,告诉浏览器 ...
    1网络应用程序架构
    (1)主机/终端
       特点:
         主机负责所有的计算(处理业务)
         终端只负责输入输出(不做任何计算)
    
       优点:
           可靠,安全,i/o能力强
       缺点:
           昂贵,扩展困难
    
     (2)client/server
        1)两层的client/server(目前不流行)
    
           客户端 <==============>   数据库
    
         (少量的业务处理)          (除了保存数据,
                                     还负责处理大量的业务逻辑)
          (vc,vb,deph1
        可视化编程语言)
    
    
             特点:使用数据库充当服务器,(大量的业务逻辑
                   是使用数据库特定的编程语言实现的)
                   客户端提供界面和少量的业务逻辑处理。
    
             优点:可视化编程语言开发速度快
             缺点:不好移植,不适合开发大型应用
              (要求客户端与数据库服务器建立一个持续链接)
    
    
       oracle编程语言:pl/sql
       sqlserver编程语言:transql
    
        2)三层的client/server(cs)
    
            客户端 <=========> 应用服务器 <=========> 数据库
    
        客户端:界面
              (a界面(gui) b通信模块)
            (vb,vc,dephi,java(swing))
    
        应用服务器:负责所有的业务逻辑处理
            (一般用java来写。 也有C\C++写的,但是移植性差)
    
        数据库:数据的存储和管理crud
    
    
        应用服务器:a通信模块 b业务模块
    
         特点:所有的业务处理都由应用服务器来做
         优点:可移植性好(一般应用服务器用java来写)
                适合开发大型的应用
         缺点:客户端需要单独安装和维护
              开发复杂
    
    
    
    
    tcp/ip socket编程
    
    自定义协议 打包
    
    (3)browser/web server(简称bs)
    
       browser <---HTTP协议-----> web server <--------> db
    
    
        browser:浏览器里面有通信模块
    
        web server:Tomcat(雄猫)www.apache.org
            里面有通信模块
    
    HTTP协议:由W3C制定的。
       BS特点:
        使用浏览器充当客户端,
        使用web服务器充当应用服务器
        使用标准化的http协议来通信
      优点:
        开发相对简单(不需要开发通信模块
        不需要自定义协议)
        不需要单独安装客户端了。
    
    2,什么是servlet
      sun公司制订的一种用来扩展web服务器功能的组件规范。
       (1)扩展web服务器功能
        web服务器收到请求之后,可以调用servlet来处理
    
       (2)组件规范
        a,什么是组件?
          符合规范,并且实现了部分功能的软件模块。
          组件一般需要部署到相应的容器里面才能运行。
            b什么是容器?
          符合规范,提供组件的运行环境的程序。
    
        tomcat提供了一个servlet容器。
        注:有些web服务器,比如iis,apache httpserver没有提供servlet容器,
        需要另外再切入或者调用单独的servlet容器才能运行servlet。(部署实施的人负责)
    
        组件不依赖特定的容器的,比如:
        我们开发了一个servlet,可以部署到其他的
            web服务器:weblogic,jetty,was等服务器。
        (因为里面都提供了符合规范的容器)
    
    3,如何写一个servlet?
    
       step1,写一个Java类,实现servlet接口或者
      继承HttpServlet抽象类
      step2,编译
      step3,打包:即创建一个具有如下结构的文件夹:
        appname
          WEB-INF
            classes(放.class字节码文件)
            lib(可选,放.jar文件)
            web.xml(部署描述文件)
       step4,部署
        将step3创建好的整个文件夹拷贝到特定文件夹下面,比如:
        tomcat一般可以拷贝到webapps下面。
       step5.启动服务器,访问
        http://ip:port/appname/url-pattern
        http://localhost:8080/firstweb/hello
    
    4,安装tomcat
       (www.apache.org下载5.5以上版本)
     step1,将tomcat安装压缩问价解压
       到/home/soft01下
       /opt/**.tar.gz
      step2,配置环境变量。
        JAVA_HOME:jdk安装路径
        CATALINA_HOME:tomcat安装路径
        PATH:添加:tomcat安装路径/bin
    
      step3启动tomcat
       cd /home/soft01/tomcat5/bin
       startup.sh(或者sh catalina.sh run)
       (windows环境下:双击startup.bat)
    
      step4:访问tomcat
      打开浏览器,输入http://localhost:8080
    
    5,写一个helloServlet
      http://ip:port/firstweb/hello
      http://localhost:8080/web01/hello
       Hello kitty
    
    
       javac -cp servlet-api.jar -d . HelloServlet.java
    
    -cp告诉编译器编译的时候可以找这个jar包
    -d  就是放在哪, 小圆点.是当前目录
    
    
    5, 使用myeclipse (或 netbeans jbuilder wsad)
    
     step1,启动myeclipse, 配置tomcat
      configer server -->servers---> tomcat  6.x-->Enable
      tomcat安装目录选中
    
    + JDK
      Launch,先用run mode(初学者)(debug mode是调试模式)
      paths  右上按钮,找到tomcat的bin目录,选中3个jar文件
      配置完毕。
    
    step2创建一个web工程
    
      Javaee
        sun公司为了解决企业级开发中的系列问题
        而制定的一系列规范和相应的api
    
       子规范:
       servlet
       jsp
       jms
       jta
    
        例如:   完成异步消息的处理: 使用jms规范
    
    
    6,servlet是如何运行的?
    
     http://localhost:8080/web01/hello?uname=tom
     http://localhost:8088/web01/hello?uname=tom
    
      ?uname=tom
      参数名 参数值
      hello tom
    
      比如,在;浏览器地址栏输入:
    http://ip:port/firstweb/hello?uname=tom
    
      step1,浏览器依据ip,port建立连接
      step2,浏览器将相关数据(比如
      请求资源路径,请求参数)打包,然后发送请求。
    
      step3,服务器解析请求数据包,然后将
      解析之后的数据保存到request对象上,
      同时,服务器还会创建一个response对象
      step4服务器依据请求资源路径找到servlet类名,创建servlet对象
      然后调用service方法
     (服务器会将之前创建好的request,response作为参数传进来)
    
      step5,在service方法里面,通过请求对象来获得请求数据(比如,请求参数)
       然后进行相应的处理,最后将处理结果
      写到response对象上。
      step6,服务器从response对象上取之前保存的处理结果,然后
      打包,发送给浏览器
      step7,浏览器响应数据包,然后依据解析的结果生成新的页面。
    ------------------------------
    what:
      tomcat : web服务器,同时也提供了运行servlet的容器
    
    how:
    
     servlet HttpServlet 
    
      appname
        WEB-INF
          classes
          lib
          web.xml
    
    webapps
    
    
    
    
    jar命令压缩web工程为.war后缀的文件
      http://ip:port/appname/url-pattern
    
    
    1,http是什么
     超文本传输协议(hypertext transfer protocol)
    
      由W3C(万维网联盟)组织制订的网络应用层协议
      浏览器与web服务器之间如何通信,以及通信所使用的数据格式
    
    (1)如何通信
    
      browser           web server 之间
               1.建立连接
               2.浏览器将请求数据打包,发送给server
               3.web服务器将响应数据打包,发送给浏览器
               4.web服务器关闭连接
    
     特点:1次请求,1次连接。
     有点:web服务器可以利用有限的连接资源为尽可能多的客户端服务。(效率高
     缺点:无状态
    
    
    (2)数据格式
       1)请求数据包  
        a,请求行 (包头):请求方式  请求资源路径 协议类型和版本
        b,若干消息头
           一般是由w3c定义的一些键值对,浏览器
            与web服务器之间可以通过这些消息头来传递一些特定的信息
               比如,浏览器可以发送“user-agent”消息头,告诉web服务器浏览器的类型和
               版本。(有时可通过代码主动生成消息头)
    
        c,实体内容  https://(带s表加密)
               只有发送post请求时,才有数据(请求参数)
    
       2)响应数据包
    
          a,状态行:协议类型和版本 状态码 状态描述
                    注:状态码,3位数字,w3c定义,表web server处理请求的的状态
                     200:正确
                     500:系统错误
                     404:依据地址找不到对应的资源
          b,若干消息头
              服务器也可以发送一些消息头给浏览器
               比如“context-type”消息头,告诉浏览器
               服务器返回的数据类型
          c,实体内容
             程序处理的结果(html文档,图片,视频等)
    
    
    建工程的时候Context root URL是真正的部署名
    myeclipse:
    properties-->myeclipse--> web--> web context-root改名
    
    eclipse:
    properties--> web project settings--> context-root改名
    
    抓包:
    window-->show view -->other -->myeclipse Common-->TCP/IP Monitor
    配置:右键空白 点propties--> add -->
    port:8888(比如)
    host name:  localhost:8080
    --> OK --> start
    (代理服务器)
    
    http://localhost:8888/web02/hello
    
    2,两种请求方式:
     (1)get方式
         1)哪些情况,会发送get请求
          a,直接输入某个地址
          b,点击链接
          c,表单默认提交的方式
          2)get请求特点
              a,会将请求参数加到请求资源路径的后面
                只能提交少量的数据(因为请求行最多只能存放约2k左右的数据)
              b,会将请求参数显示在浏览器地址栏
                (不安全,比如路由器会记录请求地址)
      (2)post方式
         1)哪些情况,会发送post请求
            设置表单的method="post"2)post请求特点
            a,会将请求参数添加到实体内容里面,可以提交
               大量的数据。
             b,不会将请求参数显示在地址栏,相对安全。
                (注意:不管是什么请求,都不会对请求数据加密,
                 一般使用https协议加密)
    ----------------
    request包内容:
    表头:
    GET /web02/hello HTTP/1.1
    
    若干消息头:
    key : value
    
    -----------------
    
    
    
    3,servlet如何输出中文
    
      (1)为什么会乱码
         out输出默认编码:iso-8859-1  一个字节一个字符
       (2)解决
              response.setContentType("text/html;charset=utf-8");
        或者  response.setContentType("text/html;charset=gbk");
    
    4,常见的错误及处理方式
      (1404
            1)错误原因
                a,应用没部署
                b,请求地址写错了
                     按照http://ip:port/appname/url-pattern
                c,<servlet-name>不一致
      (2500
             1)错误原因
                a,程序运行时出错(代码写错了)
                b,<servlet-class>写错3405
            1)错误原因
              a,服务器找不到处理方法。(例如service方法名写错)
    
       (4200为正确,非错误
    
    5,表单包含了中文参数值如何处理
      (1)为什么会有乱码?
        当表单提交时。浏览器会检查请求参数值,
       是中文,会按照打开该表达所在的页面时的字符集来编码。
       (比如按照utf-8来编码)
    
        服务器默认情况下,会使用“iso-8859-1”来解码
       (2)如何解决?
         step1,保证浏览器使用指定的字符集打开页面。
            <meta http-equiv="content-type" content="text/html;charset=utf-8">
         step2,服务器端使用对应的字符集解码
             方式一:
                request.setCharacterEncoding("utf-8");
                注意:只针对post请求有效(只针对请求包的实体内容)
               (常用,注意前提:设定为post)
    
             方式二:
            str = new String(str.getBytes("iso-8859-1"),"utf-8");
                    先拿到字节数组,然后解码
                 (不停的转码,麻烦)
    
    6,如何获得请求参数值?
       (1)  String request.getParameter(String paraName)
         注意:
           a,paraName必须与实际传递的参数名一致,否则会获得null
           b,有可能获得空字符串
    
        对于多选课和单选框,如何不选择任何选项,会获得null7,servlet如何使用JDBC访问数据库
      step1,将jdbc驱动拷贝到WEB-INF\lib下
       服务器一般都提供了自己的类加载器(比如tomcat就提供了
       自己的类加载器),这些类加载器会从
       WEB-INF\lib下查找字节码文件。
    
      step2,在servlet类里面,使用jdbc提供的ff
       来访问数据库,要注意异常的处理。
     8,mysql数据库的简单使用
      (1)登录mysql
        终端:   mysql -uroot
       (2)查看当前有哪些数据库
        show databases;
        (3)创建一个新数据库(同时设置字符集)
        create database jsd1407 default character set utf8;
        (4)使用指定的数据库
        use jsd1407
        (5)查看当前数据库有哪些表
         show tables;
        (6)建表
       create table emp(
        id int primary key auto_increment,
        name varchar(50),
        salary double,
        age int
    );
    
    auto_increment:自增长列,插入数据时,数据库自动为该列赋一个自动增长的值
    
     insert into emp(name,salary,age)
     values('sally',20000,32);
    
    select * from emp;
    
    停止服务
      出“系统繁忙”错误
    -----------------------------------
    1,http协议
      (1)what
        a,通信
    
        b,数据格式
    
            请求数据包
               请求行get post(delete,put请求是ajax带的)
               消息头 user-agent
               实体内容
    
                  post             
    
            响应数据包
                状态行
                消息头 content-type image/jepg
            实体内容
    
       (2)get/post
           get:地址,连接,表单默认。只能放少量数据
    
           post(method="post")
           https(加密,需要配置,生成证书等)
    
    2,表单
       utf-8  iso-8859-1(ascii)
       <meta http-equiv="content-type" content="text/html;charset=utf-8">
    
       request.setCharacterEncoding("utf-8");
       new String(str.getBytes("iso-8859-1"),"utf-8");
    
    
    3,输出中文
      response.setContentType("text/html;charset=utf-8")
    
    4,读取请求参数
      request.getParameter("uname");
      request.getParameterValues("intrest");
    
    5,访问数据库
      JDBC的.jar包放进WEB-INF\lib
      jdbc sql
        系统异常
    
      http://ip:port/appname/list
    
    以下信息表示这个驱动没有在tomcat注册过,所以报可能内存泄露的错误。
    (这里可不用管)
    
    严重: The web application [/web03] registered the JDBC driver [com.mysql.jdbc.Driver] but failed to unregister it when the web application was stopped. To prevent a memory leak, the JDBC Driver has been forcibly unregistered.
    2015-12-6 13:41:12 org.apache.catalina.loader.WebappClassLoader clearReferencesThreads
    严重: The web application [/web03] appears to have started a thread named [MySQL Statement Cancellation Timer] but has failed to stop it. This is very likely to create a memory leak.
    
    
    
    1,重定向
      (1)什么是重定向?
           服务器通知浏览器向一个新的地址发送请求。
    
       一般服务器可以发送一个302状态码和一个Location
       消息头(值是一个地址,一般称之为重定向地址),
       浏览器收到之后,会立即向重定向地址发请求
    
    response:
    
    HTTP/1.1 302 Found
    server:...
    Location:http://locahost:8080/web03/list
    ...
    
    
       (2)如何重定向?
           response.sendRedirect(String url);
    
    
       (3)重定向之前,服务器会清空response对象上缓存的数据。
       (4)特点
            a,重定向之后浏览器地址会变
            b,重定向地址是任意的。
    
    2,servlet容器如何处理请求资源路径
      比如,在浏览器地址栏输入
          浏览器会将“http://ip:port/web03_2/abc.html”
         作为请求资源路径发送给servlet容器(tomcat)
       step1,依据应用名找到应用所在的文件夹。
       step2,容器会先假设访问的是一个servlet,
        会从web.xml文件当中查找对应的servlet来处理
         (1)精确匹配
          <url-pattern>/abc.html</url-pattern>
             (假设abc.html文件同时存在,也不访问abc.html这个文件)
    
         (2)通配符匹配
          使用“*”来匹配0个或多个字符
         比如:
             <url-pattern>/*</url-pattern>
             <url-pattern>/abc/*</url-pattern>
    
    
           (3)后缀匹配
             使用“*.”开头,后接多个字符
             <url-pattern>/*.do</url-pattern>
             匹配所有以“.do”结尾的请求
        step3,如果以上均不匹配,会查找文件。找到了就返回,
             找不到就返回404
    
      (servlet其实是单例,只创建一个对象)
    3,让一个servlet处理多种请求
       step1,使用后缀匹配
           <url-pattern>/*.do</url-pattern>
    
       step2,分析请求资源路径,依据分析结果,调用
          不同的分支来处理。
              //获得请求资源路径
          String uri = request.getRequestURI();
    
    junit:右键--> other -->java -->Junit -->Junit test case
            junit4
    
    
    
    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class HelloServlet extends HttpServlet{
        public void service(HttpServletRequest request,
                HttpServletResponse response)
        throws ServletException,IOException{
            //读请求参数值
            String uname=request.getParameter("uname");
            /*
             * 消息头:告诉浏览器,服务器返回数据的类型。
             */
            response.setContentType("text/html");
            //通过response获得输出流
            PrintWriter out = response.getWriter();
            //输出
            out.println("<div style='font-size:60px;'>Hello "
                    +uname+"</div>");
    
            //out.close()方法包含flush方法,
            //out.close()不写也可,因为servlet执行完毕会自动调用
            out.close();
        }
    }
    
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
      <servlet>
        <servlet-name>helloServlet</servlet-name>
        <!-- 写完整的类名 反射 -->
        <servlet-class>web.HelloServlet</servlet-class>
      </servlet>
      <servlet-mapping>
        <!-- 注意要上下一致 -->
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
      </servlet-mapping>
    </web-app>
    

    —-(2)———————————————

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    public class HelloServlet extends HttpServlet{
        //如果没有继承HttpServlet,会报500错误
    
        public void service(HttpServletRequest request,
                HttpServletResponse response)
        throws ServletException,IOException{
            /*
             * 方式一:
             * 设置解析请求数据的编码集
             * 注意:request.setCharacterEncoding("utf-8")
             * 只针对post请求有效(只针对请求包的实体内容)
             */
            request.setCharacterEncoding("utf-8");
    
            //Integer.parseInt("111a");//会报500错误
    
            //读请求参数值
            String uname=request.getParameter("uname");
    
            String[] intrest = request.getParameterValues("intrest");
            for(int i=0;i<intrest.length;i++){
                System.out.println(intrest[i]);
            }
    
    
            /*
             * 方式二,需要不停的转换,不推荐
             */
            //uname = new String(
            //      uname.getBytes("iso-8859-1"),"utf-8");
    
            /*
             * 消息头:告诉浏览器,服务器返回数据的类型。
             */
            response.setContentType("text/html;charset=utf-8");
            //通过response获得输出流
            PrintWriter out = response.getWriter();
            /*
             * 输出 编码  unicode(2个字节表示一个字符)
             * out输出默认编码:iso-8859-1  一个字节一个字符
             * 如果setContentType方法指定的charset=某字符集,
             * 则会使用该字符集去编码
             */
            out.println("<div style='font-size:60px;'>Hello你好 "
                    +uname+"</div>");
    
            //out.close()方法包含flush方法,
            //out.close()不写也可,因为servlet执行完毕会自动调用
            out.close();
        }
    }
    
    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    
    
    public class AddEmpServlet extends HttpServlet{
    
        public void service(HttpServletRequest request,
                HttpServletResponse response)
        throws ServletException,IOException{
            /*
             * 方式一:
             * 设置解析请求数据的编码集
             * 注意:request.setCharacterEncoding("utf-8")
             * 只针对post请求有效(只针对请求包的实体内容)
             */
            request.setCharacterEncoding("utf-8");
    
            /*
             * 服务器端通常检查参数是否为null,此处暂时不做
             */
            //读请求参数值
            String name=request.getParameter("empname");
            String salary=request.getParameter("salary");
            String age=request.getParameter("age");
    
            /*
             * 消息头:告诉浏览器,服务器返回数据的类型。
             */
            response.setContentType("text/html;charset=utf-8");
            //通过response获得输出流
            PrintWriter out = response.getWriter();
            /*
             * 输出 编码  unicode(2个字节表示一个字符)
             * out输出默认编码:iso-8859-1  一个字节一个字符
             * 如果setContentType方法指定的charset=某字符集,
             * 则会使用该字符集去编码
             */
            //out.println("<div style='font-size:30px;'> "
                    //+empname+salary+age+"</div>");
    
            //插入数据库
            Connection conn = null;
            PreparedStatement stat = null;
            try {
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsd1407?useUnicode=true&characterEncoding=utf8", "root", "zaq12wsx");
                stat = conn.prepareStatement(
                        "INSERT INTO emp(name,salary,age) " +
                        "VALUES(?,?,?)");
                //oracle :  (seq.nextval,?,?)
    
                stat.setString(1, name);
                stat.setDouble(2,Double.parseDouble(salary));
                stat.setInt(3, Integer.parseInt(age));
    
                stat.executeUpdate();
                out.println("添加员工成功");
    
            } catch (Exception e) {
                //记录日志,应该写到文件或数据库,此处暂用e.printStackTrace()处理
                e.printStackTrace();//打印异常的堆栈信息
                /*
                 * 看异常是否能恢复,如果不能恢复
                 * (比如数据库服务停止,网络中断等产生的异常,一般称为系统异常),
                 * 则提示用户稍后重试
                 * 
                 * (能恢复的异常叫应用异常)
                 */
                out.println("系统繁忙,请稍后重试");
    
            }finally{
    
                //stat.close();//用连接的时候,先关闭结果集,再关闭statement,再关闭连接
                //此处只需关闭conn(stat会自动关闭)
    
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                    }
                }
            }
    
    
            //out.close()方法包含flush方法,
            //out.close()不写也可,因为servlet执行完毕会自动调用
            out.close();
        }
    }
    
    package web;
    
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.net.URLEncoder;
    
    public class Test {
    
        /**
         * @param args
         * @throws UnsupportedEncodingException 
         */
        public static void main(String[] args) throws UnsupportedEncodingException {
            String str = "过儿";
            //編碼
            String str2 = URLEncoder.encode(str,"utf-8");
            System.out.println(str2);
    
            //解碼
            String str3 = URLDecoder.decode(str2, "UTF-8");
            System.out.println(str3);
        }
    
    }
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <title>MyHtml.html</title>
    
    
        <!-- 模拟content-type消息头  告诉浏览器解析信息-->
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
        <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
    
      </head>
    
      <body style="font-size:24px;font-style:italic;">
        <form action="hello" method="post">
          <fieldset>
            <legend>欢迎</legend>
            用户名:<input name="uname"/>
    
            <br/>
            爱好:放鱼<input type="checkbox" name="intrest" value="fishing" checked="checked"/>
            做饭<input type="checkbox" name="intrest" value="cooking"/>
            足球<input type="checkbox" name="intrest" value="football"/>
            <br/>
             <input type="submit" value="提交"/>
          </fieldset>
        </form>
      </body>
    </html>
    
    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <title>MyHtml.html</title>
    
        <!-- 模拟content-type消息头  告诉浏览器解析信息-->
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
        <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
    
      </head>
    
      <body style="font-size:24px;font-style:italic;">
        <form action="add" method="post">
          <fieldset>
            <legend>欢迎</legend>
            员工姓名<input name="empname"/><br/>
            工资<input name="salary"/><br/>
            年龄<input name="age"/><br/>
             <input type="submit" value="提交"/>
          </fieldset>
        </form>
      </body>
    </html>
    
    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
      <servlet>
        <servlet-name>helloServlet</servlet-name>
        <!-- 写完整的类名 反射 -->
        <servlet-class>web.HelloServlet</servlet-class>
      </servlet>
      <servlet>
        <servlet-name>addEmpServlet</servlet-name>
        <servlet-class>web.AddEmpServlet</servlet-class>
      </servlet>
    
    
      <servlet-mapping>
        <!-- 注意name要上下一致 -->
        <servlet-name>helloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
      </servlet-mapping>
       <servlet-mapping>
        <servlet-name>addEmpServlet</servlet-name>
        <url-pattern>/add</url-pattern>
      </servlet-mapping>
    </web-app>
    

    –(3)————————————

    dao

    package dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.ArrayList;
    import java.util.List;
    
    import util.DBUtil;
    import entity.Employee;
    //junit 单元测试 白盒测试
    public class EmployeeDAO {
        public void save(Employee e) throws Exception{
            Connection conn = null;
            try {
                conn = DBUtil.getConnection();
    
                PreparedStatement stat = conn.prepareStatement(
                        "INSERT INTO emp(name,salary,age) " +
                        "VALUES(?,?,?)");
                stat.setString(1, e.getName());
                stat.setDouble(2, e.getSalary());
                stat.setInt(3, e.getAge());
    
                stat.executeUpdate();
    
            } catch (Exception e1) {
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
    
        public List<Employee> findAll() throws Exception{
            List<Employee> employees = new ArrayList<Employee>();
            Connection conn =null;
    
            try {
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "SELECT * FROM emp");
                ResultSet rs = stat.executeQuery();
    
                while(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    double salary = rs.getDouble("salary");
                    int age = rs.getInt("age");
                    Employee e = new Employee(id,name,salary,age);
                    employees.add(e);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }finally{
                DBUtil.closeConnection(conn);
            }
            return employees;
    
        }
        public void deleteById(int id) throws Exception{
            Connection conn =null;
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "DELETE FROM emp WHERE id=?");
                stat.setInt(1, id);
                stat.executeUpdate();
            }catch(Exception e){
                e.printStackTrace();
                throw e;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
        public Employee loadById(int id) throws Exception{
            Employee e = null;
            Connection conn = null;
    
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "SELECT * FROM emp WHERE id=?");
                stat.setInt(1, id);
                ResultSet rs = stat.executeQuery();
                if(rs.next()){
                    e = new Employee(
                            id,
                            rs.getString("name"),
                            rs.getDouble("salary"),
                            rs.getInt("age"));
                }
            }catch(Exception e1){
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
    
            return e;
        }
    
        public void modify(Employee e) throws Exception{
            Connection conn =null;
    
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "UPDATE emp  SET name=?,salary=?,age=? where id=?");
                stat.setString(1, e.getName());
                stat.setDouble(2, e.getSalary());
                stat.setInt(3, e.getAge());
                stat.setInt(4, e.getId());
                stat.executeUpdate();
            }catch(Exception e1){
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
    }
    

    DAOtest

    package dao;
    
    import java.util.List;
    
    import junit.framework.TestCase;
    import entity.Employee;
    /**
     * junit:右键--> other -->java -->Junit -->Junit test case
            junit4
     * @author Administrator
     * windows-->show view -->outline
     *
     */
    public class EmployeeDAOTest extends TestCase {
    
        public void testSave() throws Exception {
    //      //fail("Not yet implemented");
            EmployeeDAO dao = new EmployeeDAO();
            Employee e = new Employee();
            e.setName("kkk");
            e.setSalary(20000);
            e.setAge(33);
            dao.save(e);
    
        }
    
        public void testFindAll() throws Exception {
            EmployeeDAO dao = new EmployeeDAO();
            List<Employee> employees = dao.findAll();
            System.out.println(employees);
        }
    
        public void testDeleteById() throws Exception {
            EmployeeDAO dao = new EmployeeDAO();
            dao.deleteById(8);
        }
    
        public void testLoadById() throws Exception {
            EmployeeDAO dao = new EmployeeDAO();
            Employee e = dao.loadById(1);
            System.out.println(e);
        }
    
        public void testModify() throws Exception {
            EmployeeDAO dao = new EmployeeDAO();
            Employee e = new Employee();
            e.setId(3);
            e.setName("Sherry");
            e.setSalary(20000);
            e.setAge(33);
            dao.modify(e);
        }
    
    }
    

    emp实体类

    package entity;
    /**
     * 实体类
     * 用于封装从数据库查询出来的记录的
     * @author Administrator
     *
     */
    public class Employee {
        private int id;
        private String name;
        private double salary;
        private int age;
        public Employee() {
            super();
        }
        public Employee(int id, String name, double salary, int age) {
            super();
            this.id = id;
            this.name = name;
            this.salary = salary;
            this.age = age;
        }
        public int getId() {
            return id;
        }
        public void setId(int id) {
            this.id = id;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public double getSalary() {
            return salary;
        }
        public void setSalary(double salary) {
            this.salary = salary;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        //通常加实体类的时候会加toString方法
        @Override
        public String toString() {
            return "("+id+","+name+","+salary+","+age+")";
        }
    
    
    }
    

    DB工具类

    package util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    /**
     * JDBC工具类
     */
    public class DBUtil {
        public static Connection getConnection() throws Exception{
            Connection conn = null;
    
            try {
                Class.forName("com.mysql.jdbc.Driver");
                /*
                         * ?useUnicode=true&characterEncoding=utf8
                         * 这两个选项参数的作用是告诉jdbc驱动使用
                         *"utf-8"来编码和解码。
                         */
                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/jsd1407?useUnicode=true&characterEncoding=utf8",
                        "root",
                        "zaq12wsx");
    
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }
            return conn;
        }
    
        public static void closeConnection(Connection conn){
            if(conn != null){
                try {
                    /*
                     * 连接建好后,才会返回connection对象
                     * 所以打印getConnection()来测试方法的正确与否
                     */
                    conn.close();
                } catch (SQLException e) {
                }
            }
        }
    
        public static void main(String[] args){
    
            try {
                System.out.println(getConnection());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }
    

    添加员工

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    import entity.Employee;
    
    import util.DBUtil;
    
    
    
    public class AddEmpServlet extends HttpServlet{
    
        public void service(HttpServletRequest request,
                HttpServletResponse response)
        throws ServletException,IOException{
            /*
             * 方式一:
             * 设置解析请求数据的编码集
             * 注意:request.setCharacterEncoding("utf-8")
             * 只针对post请求有效(只针对请求包的实体内容)
             */
            request.setCharacterEncoding("utf-8");
    
            /*
             * 服务器端通常检查参数是否为null,此处暂时不做
             */
            //读请求参数值
            String name=request.getParameter("empname");
            String salary=request.getParameter("salary");
            String age=request.getParameter("age");
    
            /*
             * 消息头:告诉浏览器,服务器返回数据的类型。
             */
            response.setContentType("text/html;charset=utf-8");
            //通过response获得输出流
            PrintWriter out = response.getWriter();
            /*
             * 输出 编码  unicode(2个字节表示一个字符)
             * out输出默认编码:iso-8859-1  一个字节一个字符
             * 如果setContentType方法指定的charset=某字符集,
             * 则会使用该字符集去编码
             */
            //out.println("<div style='font-size:30px;'> "
                    //+empname+salary+age+"</div>");
    
            //插入数据库
    
            try {
                /**
                conn = DBUtil.getConnection();
                //Class.forName("com.mysql.jdbc.Driver");
                  //conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/jsd1407", "root", "zaq12wsx");
    
                stat = conn.prepareStatement(
                        "INSERT INTO emp(name,salary,age) " +
                        "VALUES(?,?,?)");
                //oracle :  (seq.nextval,?,?)
    
                stat.setString(1, name);
                stat.setDouble(2,Double.parseDouble(salary));
                stat.setInt(3, Integer.parseInt(age));
    
                stat.executeUpdate();
                */
    
                //out.println("添加员工成功");
                /*
                 * 重定向之前,服务器会清空response对象上缓存的数据。
                 * 所以,"添加员工成功"不显示
                 * 
                 * out.println()实际上还没发送,
                 * 而是保存在response对象上
                 * 解决方法如下为使用JS:
                 */
                /*
                 * setTimeOut(function(){
                 * location='list'},1000)
                 */
                /*
                out.println("添加员工成功");
                out.close();*/
    
                EmployeeDAO dao = new EmployeeDAO();
                Employee e = new Employee();
                e.setName(name);
                e.setSalary(Double.parseDouble(salary));
                e.setAge(Integer.parseInt(age));
                dao.save(e);
                response.sendRedirect("list");
    
                //可指定网址:
                //response.sendRedirect("http://www.tmooc.cn/web/library/library.html");
                //System.out.println("重定向之后的代码会执行");
                //out.println("<a href='list'>员工列表</a>");
    
            } catch (Exception e) {
                //记录日志,应该写到文件或数据库,此处暂用e.printStackTrace()处理
                e.printStackTrace();//打印异常的堆栈信息
                /*
                 * 看异常是否能恢复,如果不能恢复
                 * (比如数据库服务停止,网络中断等产生的异常,一般称为系统异常),
                 * 则提示用户稍后重试
                 * 
                 * (能恢复的异常叫应用异常)
                 */
                out.println("系统繁忙,请稍后重试");
    
            }/*finally{
    
                //stat.close();//用连接的时候,先关闭结果集,再关闭statement,再关闭连接
                //此处只需关闭conn(stat会自动关闭)
                DBUtil.closeConnection(conn);
                /*
                if(conn != null){
                    try {
                        conn.close();
                    } catch (SQLException e) {
                    }
                }*/
            //}
    
    
            //out.close()方法包含flush方法,
            //out.close()不写也可,因为servlet执行完毕会自动调用
            out.close();
        }
    }
    

    删除员工

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    
    public class DelEmpServlet extends HttpServlet{
        public void service(HttpServletRequest request,
                HttpServletResponse response) throws
                ServletException,IOException{
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
    
            int id = Integer.parseInt(request.getParameter("id"));
    
            try{
                EmployeeDAO dao = new EmployeeDAO();
                dao.deleteById(id);
                response.sendRedirect("list");
            }catch(Exception e){
                e.printStackTrace();
                out.println("稍后重试");
            }
    
        }
    
    }
    

    员工一览

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    import entity.Employee;
    
    public class ListEmpServlet extends HttpServlet{
        public void service(HttpServletRequest request,
                HttpServletResponse response) throws
                ServletException,IOException{
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
    
            try {
                EmployeeDAO dao = new EmployeeDAO();
                List<Employee> employees = dao.findAll();
    
                out.println("<table width='60%' border='1' cellspacing='0' cellpadding='0'>");
                out.println("<tr><td>ID</td><td>姓名</td><td>薪水</td><td>年龄</td><td>操作</td></tr>");
    
    
                for(int i=0;i<employees.size();i++){
                    Employee e = employees.get(i);
                    int id = e.getId();
                    out.println("<tr><td>"+
                            e.getId()+"</td><td>"+
                            e.getName()+"</td><td>"+
                            e.getSalary()+"</td><td>"+
                            e.getAge()+"</td><td><a href='del?id="+id+"'>删除</a>" +
                                    "&nbsp;<a href='load?id="+id+"'>修改</a></td></tr>");
                }
    
                out.println("</table>");
                out.println("<a href='addEmp.html'>添加员工</a>");
            } catch (Exception e) {
                e.printStackTrace();
                out.println("稍后重试");
            }
        }
    
    }
    

    修改第一步:load

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    import entity.Employee;
    
    public class LoadEmpServlet extends HttpServlet{
        public void service(HttpServletRequest request,
                HttpServletResponse response) throws
                ServletException,IOException{
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
    
            int id = Integer.parseInt(request.getParameter("id"));
            try{
                EmployeeDAO dao = new EmployeeDAO();
    
                Employee e = dao.loadById(id);
                if(e != null){
                    String name = e.getName();
                    double salary = e.getSalary();
                    int age = e.getAge();
    
                    out.println("<form action='modify' method='post'>");
                    out.println("id:"+id+"<br/>");
                    out.println("姓名:<input name='name' value='"+name+"'/><br/>");
                    out.println("薪水:<input name='salary' value='"+salary+"'/><br/>");
                    out.println("年龄:<input name='age' value='"+age+"'/><br/>");
                    //隐藏域
                    out.println("年龄:<input type='hidden' name='id' value='"+id+"'/><br/>");
    
                    out.println("<input type='submit' value='提交'/>");
    
                    out.println("</form>");
                }
            }catch(Exception e){
                e.printStackTrace();
                out.println("稍后重试");
            }
        }
    
    }
    
    

    修改员工第二部

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    import entity.Employee;
    
    public class ModifyEmpServlet extends HttpServlet{
        public void service(HttpServletRequest request,
                HttpServletResponse response) throws
                ServletException,IOException{
            request.setCharacterEncoding("utf-8");
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
    
            int id = Integer.parseInt(request.getParameter("id"));
            String name = request.getParameter("name");
            String salary = request.getParameter("salary");
            String age = request.getParameter("age");
    
            Employee e = new Employee(id,name,Double.parseDouble(salary),Integer.parseInt(age));
            try{
                EmployeeDAO dao = new EmployeeDAO();
                dao.modify(e);
                response.sendRedirect("list");
    
            }catch(Exception e1){
                e1.printStackTrace();
                out.println("稍后重试");
            }
        }
    
    }
    

    添加员工html

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <title>addEmp.html</title>
    
        <!-- 模拟content-type消息头  告诉浏览器解析信息-->
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
        <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
    
      </head>
    
      <body>
        <form action="add" method="post">
          <fieldset>
            <legend>欢迎</legend>
            姓名<input name="name" /><br/><br/>
            工资<input name="salary" /><br/><br/>
            年龄<input name="age" /><br/><br/>
            <input type="submit" value="提交">
          </fieldset>
        </form>
      </body>
    </html>
    

    xml配置文件

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
      <servlet>
        <servlet-name>ListEmpServlet</servlet-name>
        <servlet-class>web.ListEmpServlet</servlet-class>
      </servlet>
      <servlet>
        <servlet-name>addEmpServlet</servlet-name>
        <servlet-class>web.AddEmpServlet</servlet-class>
      </servlet>
      <servlet>
        <servlet-name>delEmpServlet</servlet-name>
        <servlet-class>web.DelEmpServlet</servlet-class>
      </servlet>
      <servlet>
        <servlet-name>loadEmpServlet</servlet-name>
        <servlet-class>web.LoadEmpServlet</servlet-class>
      </servlet>
      <servlet>
        <servlet-name>modifyEmpServlet</servlet-name>
        <servlet-class>web.ModifyEmpServlet</servlet-class>
      </servlet>
    
    
      <servlet-mapping>
        <servlet-name>ListEmpServlet</servlet-name>
        <url-pattern>/list</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>addEmpServlet</servlet-name>
        <url-pattern>/add</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>delEmpServlet</servlet-name>
        <url-pattern>/del</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>loadEmpServlet</servlet-name>
        <url-pattern>/load</url-pattern>
      </servlet-mapping>
      <servlet-mapping>
        <servlet-name>modifyEmpServlet</servlet-name>
        <url-pattern>/modify</url-pattern>
      </servlet-mapping>
    </web-app>
    

    —(3_2)合并servlet uri(mysql和oracle)————————-

    DBUtil

    package util;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    /**
     * JDBC工具类
     */
    public class DBUtil {
        public static Connection getConnection() throws Exception{
            Connection conn = null;
    
            try {
                /*mysql:
                Class.forName("com.mysql.jdbc.Driver");
                conn = DriverManager.getConnection(
                        "jdbc:mysql://localhost:3306/jsd1407",
                        "root",
                        "zaq12wsx");
                */
                //oracle
                Class.forName("oracle.jdbc.driver.OracleDriver");
                conn = DriverManager.getConnection(
                        "jdbc:oracle:thin:@localhost:1521:xe",
                        "system",
                        "zaq12wsx");
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }
            return conn;
        }
    
        public static void closeConnection(Connection conn){
            if(conn != null){
                try {
                    /*
                     * 连接建好后,才会返回connection对象
                     * 所以打印getConnection()来测试方法的正确与否
                     */
                    conn.close();
                } catch (SQLException e) {
                }
            }
        }
    
        public static void main(String[] args){
    
            try {
                System.out.println(getConnection());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
    }
    

    EmployeeDAO

    package dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.util.ArrayList;
    import java.util.List;
    
    import util.DBUtil;
    import entity.Employee;
    //junit 单元测试 白盒测试
    public class EmployeeDAO {
        public void save(Employee e) throws Exception{
            Connection conn = null;
            try {
                conn = DBUtil.getConnection();
    
                /*mysql
                PreparedStatement stat = conn.prepareStatement(
                        "INSERT INTO emp(name,salary,age) " +
                        "VALUES(?,?,?)");
                        */
    
                //Oracle
                PreparedStatement stat = conn.prepareStatement(
                        "INSERT INTO emp(id,name,salary,age) " +
                        "VALUES(emp_id_seq.nextval,?,?,?)");
                stat.setString(1, e.getName());
                stat.setDouble(2, e.getSalary());
                stat.setInt(3, e.getAge());
    
                stat.executeUpdate();
    
            } catch (Exception e1) {
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
    
        public List<Employee> findAll() throws Exception{
            List<Employee> employees = new ArrayList<Employee>();
            Connection conn =null;
    
            try {
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "SELECT * FROM emp");
                ResultSet rs = stat.executeQuery();
    
                while(rs.next()){
                    int id = rs.getInt("id");
                    String name = rs.getString("name");
                    double salary = rs.getDouble("salary");
                    int age = rs.getInt("age");
                    Employee e = new Employee(id,name,salary,age);
                    employees.add(e);
                }
    
            } catch (Exception e) {
                e.printStackTrace();
                throw e;
            }finally{
                DBUtil.closeConnection(conn);
            }
            return employees;
    
        }
        public void deleteById(int id) throws Exception{
            Connection conn =null;
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "DELETE FROM emp WHERE id=?");
                stat.setInt(1, id);
                stat.executeUpdate();
            }catch(Exception e){
                e.printStackTrace();
                throw e;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
        public Employee loadById(int id) throws Exception{
            Employee e = null;
            Connection conn = null;
    
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "SELECT * FROM emp WHERE id=?");
                stat.setInt(1, id);
                ResultSet rs = stat.executeQuery();
                if(rs.next()){
                    e = new Employee(
                            id,
                            rs.getString("name"),
                            rs.getDouble("salary"),
                            rs.getInt("age"));
                }
            }catch(Exception e1){
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
    
            return e;
        }
    
        public void modify(Employee e) throws Exception{
            Connection conn =null;
    
            try{
                conn = DBUtil.getConnection();
                PreparedStatement stat = conn.prepareStatement(
                        "UPDATE emp  SET name=?,salary=?,age=? where id=?");
                stat.setString(1, e.getName());
                stat.setDouble(2, e.getSalary());
                stat.setInt(3, e.getAge());
                stat.setInt(4, e.getId());
                stat.executeUpdate();
            }catch(Exception e1){
                e1.printStackTrace();
                throw e1;
            }finally{
                DBUtil.closeConnection(conn);
            }
        }
    }
    

    ActionServlet

    package web;
    
    import java.io.IOException;
    import java.io.PrintWriter;
    import java.util.List;
    
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import dao.EmployeeDAO;
    import entity.Employee;
    
    public class ActionServlet extends HttpServlet{
        public ActionServlet(){
            //servlet其实是单例,只创建一个对象
            System.out.println("ActionServlet's constructor..");
        }
    
        public void service(HttpServletRequest request,
                HttpServletResponse response)
        throws ServletException,IOException{
            request.setCharacterEncoding("utf-8");
            response.setContentType("text/html;charset=utf-8");
            PrintWriter out = response.getWriter();
    
            //System.out.println("ActionSevlet service");
    
            //获得请求资源路径
            String uri = request.getRequestURI();
            //System.out.println("uri:"+uri);
    
            //分析请求资源路径
            String action = uri.substring(uri.lastIndexOf("/")+1,uri.lastIndexOf("."));
            //System.out.println("action:"+action);
            //依据分析结果调用不同的名字来处理
    
            //获取列表
            if("list".equals(action)){
                try {
                    EmployeeDAO dao = new EmployeeDAO();
                    List<Employee> employees = dao.findAll();
    
                    out.println("<table width='60%' border='1' cellspacing='0' cellpadding='0'>");
                    out.println("<tr><td>ID</td><td>姓名</td><td>薪水</td><td>年龄</td><td>操作</td></tr>");
    
    
                    for(int i=0;i<employees.size();i++){
                        Employee e = employees.get(i);
                        int id = e.getId();
                        out.println("<tr><td>"+
                                e.getId()+"</td><td>"+
                                e.getName()+"</td><td>"+
                                e.getSalary()+"</td><td>"+
                                e.getAge()+"</td><td><a href='del.do?id="+id+"'>删除</a>" +
                                        "&nbsp;<a href='load.do?id="+id+"'>修改</a></td></tr>");
                    }
    
                    out.println("</table>");
                    out.println("<a href='addEmp.html'>添加员工</a>");
                } catch (Exception e) {
                    e.printStackTrace();
                    out.println("系统繁忙");
                }
                //添加员工
            }else if("add".equals(action)){
    
                //读请求参数值
                String name= request.getParameter("name");
                String salary= request.getParameter("salary");
                String age= request.getParameter("age");
                try {
                    Employee e = new Employee();
                    e.setName(name);
                    e.setSalary(Double.parseDouble(salary));
                    e.setAge(Integer.parseInt(age));
    
                    EmployeeDAO dao = new EmployeeDAO();
                    dao.save(e);
                    response.sendRedirect("list.do");
                } catch (Exception e) {
                    e.printStackTrace();
                    out.println("系统繁忙");
                }   
                //删除员工
            }else if("del".equals(action)){
                int id = Integer.parseInt(request.getParameter("id"));
    
                try{
                    EmployeeDAO dao = new EmployeeDAO();
                    dao.deleteById(id);
                    response.sendRedirect("list.do");
                }catch(Exception e){
                    e.printStackTrace();
                    out.println("稍后重试");
                }
                //修改第一步load
            }else if("load".equals(action)){
                int id = Integer.parseInt(request.getParameter("id"));
                try{
                    EmployeeDAO dao = new EmployeeDAO();
    
                    Employee e = dao.loadById(id);
                    if(e != null){
                        String name = e.getName();
                        double salary = e.getSalary();
                        int age = e.getAge();
    
                        out.println("<form action='modify.do' method='post'>");
                        out.println("id:"+id+"<br/>");
                        out.println("姓名:<input name='name' value='"+name+"'/><br/>");
                        out.println("薪水:<input name='salary' value='"+salary+"'/><br/>");
                        out.println("年龄:<input name='age' value='"+age+"'/><br/>");
                        //隐藏域
                        out.println("年龄:<input type='hidden' name='id' value='"+id+"'/><br/>");
    
                        out.println("<input type='submit' value='提交'/>");
    
                        out.println("</form>");
                    }
                }catch(Exception e){
                    e.printStackTrace();
                    out.println("稍后重试");
                }
                //修改员工第二部,modify
            }else if("modify".equals(action)){
                int id = Integer.parseInt(request.getParameter("id"));
                String name = request.getParameter("name");
                String salary = request.getParameter("salary");
                String age = request.getParameter("age");
    
                Employee e = new Employee(id,name,Double.parseDouble(salary),Integer.parseInt(age));
                try{
                    EmployeeDAO dao = new EmployeeDAO();
                    dao.modify(e);
                    response.sendRedirect("list.do");
    
                }catch(Exception e1){
                    e1.printStackTrace();
                    out.println("稍后重试");
                }
            }
        }
    
    }
    

    web.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app version="2.5" 
        xmlns="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
        xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
        http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
      <servlet>
        <servlet-name>action</servlet-name>
        <servlet-class>web.ActionServlet</servlet-class>
      </servlet>
    
      <servlet-mapping>
        <servlet-name>action</servlet-name>
        <url-pattern>*.do</url-pattern>
      </servlet-mapping>
    </web-app>
    

    addEmp.html

    <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
    <html>
      <head>
        <title>addEmp.html</title>
    
        <!-- 模拟content-type消息头  告诉浏览器解析信息-->
        <meta http-equiv="content-type" content="text/html; charset=UTF-8">
    
        <!--<link rel="stylesheet" type="text/css" href="./styles.css">-->
    
      </head>
    
      <body>
        <form action="add.do" method="post">
          <fieldset>
            <legend>欢迎</legend>
            姓名<input name="name" /><br/><br/>
            工资<input name="salary" /><br/><br/>
            年龄<input name="age" /><br/><br/>
            <input type="submit" value="提交">
          </fieldset>
        </form>
      </body>
    </html>
    
    展开全文
  • Servlet简介

    万次阅读 2014-05-25 14:01:13
    开发servlet程序步骤: step1. 写一个java类,实现Servelt接口或者继承Httpservlet类,一般 继承Httpservlet类(实现了Servelt接口). step2.编译(servlet-api.jar). step3.打包 appname(目录,程序名) WEB-INF...

     

     

    前言


    1.servlet简介
      a.b/s  架构 
       browser/server,就是客户端采用浏览器,服务器端采用web server。浏览器和   服务器端之间采用http协议进行通讯。相对于c/s架构的优势:
        1.不需要关系通讯的问题,c/s架构需要自己写代码来定义通讯协议,难度比较大。
        2.浏览器不需要单独安装,可维护性更好,c/s架构需要下载客户端。
       服务器端负责通讯,我们可以使用servlet/jsp技术来显示业务逻辑,处理业务逻辑。
      b.组件和容器
        组件:符合规范的可以单独部署的程序模块。
       (部署:将该组件复制到容器的指定的目录,容器会自动调用)
        容器:符合规范的程序,主要用来管理组件的生命周期(比如,组件实例创建、组件的调用、组件销毁),
        同时给组件提供运行环境。
      c.servlet 
         就是sun公司提供的用于扩展web功能组件技术。         
       
        

    正文

    Servlet


     
     网页    静态网页(HTML)   动态网页   JavaEE规范   Servlet---Jsp

     


    什么是Servlet?

    Interface servlet is a small Java program that runs within a Web server. Servlets receive and respond to requests from Web clients

    展开全文
  • Caused by: java.lang.ClassCastException: org.springframework.web.SpringServletContainerInitializer cannot be cast to javax.servlet.ServletContainerInitializer at org.apache.catalina.startup....

    今天导入别人的工程,发现报错了。。放源码

    java.util.concurrent.ExecutionException: org.apache.catalina.LifecycleException: Failed to start component [StandardEngine[Tomcat].StandardHost[localhost].StandardContext[]]
    	at java.util.concurrent.FutureTask.report(FutureTask.java:122)
    	at java.util.concurrent.FutureTask.get(FutureTask.java:188)
    	at org.apache.catalina.core.ContainerBase.startInternal(ContainerBase.java:1123)
    	at org.apache.catalina.core.StandardHost.startInternal(StandardHost.java:800)
    	at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)
    	at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1559)
    	at org.apache.catalina.core.ContainerBase$StartChild.call(ContainerBase.java:1549)
    	at java.util.concurrent.FutureTask.run(FutureTask.java:262)
    	at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1145)
    	at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:615)
    	at java.lang.Thread.run(Thread.java:745)
    Caused by: org.apache.catalina.LifecycleException: Failed to start component [StandardEngine[Tomcat].StandardHost[localhost].StandardContext[]]
    	at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:154)
    	... 6 more
    Caused by: java.lang.ClassCastException: org.springframework.web.SpringServletContainerInitializer cannot be cast to javax.servlet.ServletContainerInitializer
    	at org.apache.catalina.startup.ContextConfig.getServletContainerInitializer(ContextConfig.java:1661)
    	at org.apache.catalina.startup.ContextConfig.processServletContainerInitializers(ContextConfig.java:1569)
    	at org.apache.catalina.startup.ContextConfig.webConfig(ContextConfig.java:1277)
    	at org.apache.catalina.startup.ContextConfig.configureStart(ContextConfig.java:878)
    	at org.apache.catalina.startup.ContextConfig.lifecycleEvent(ContextConfig.java:369)
    	at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:119)
    	at org.apache.catalina.util.LifecycleBase.fireLifecycleEvent(LifecycleBase.java:90)
    	at org.apache.catalina.core.StandardContext.startInternal(StandardContext.java:5179)
    	at org.apache.catalina.util.LifecycleBase.start(LifecycleBase.java:150)
    	... 6 more
    
    

    居然遇到了这个错,然后百度了一下,有一位博主成功解决了我的问题,我也顺便把网站贴出来把

    发现原来是包冲突的问题,我就和朋友讨论了一下,他给我的解释是这样的。
    因为使用了maven自带的tomcat插件和依赖的包有冲突了,必须给依赖的包设置范围就可以了。

    在这里插入图片描述
    注:provided范围主要是用在编译的时候使用

    展开全文
  • Servlet入门

    2019-10-21 23:43:06
    文章目录Servlet简介Servlet运行过程Servlet生命周期Servlet实现类Servlet创建Servlet映射路径问题Servlet重定向ServletContext类通过ServletContext对象读取网站配置文件简单验证码应用 Servlet简介 Servlet是sun...

    Servlet简介

    • Servlet是sun公司提供的一门用于开发动态web资源的技术

    • Sun公司在其API中提供了一个Servlet接口,用户若想发一个动态web资源(即开发一个Java程序向浏览器输出数据),需要完成以下2个步骤:

      • 编写一个Java类,实现servlet接口
      • 把开发好的java类部署到web服务器中
    • 按照约定俗成的称呼习惯,通常也把实现了servlet接口的java程序,称之为Servlet

    Servlet运行过程

    • Web浏览器 -> 发出HTTP请求 -> Web容器
    • Web容器 -> 首次访问创建目标Servlet -> Servlet
    • Web容器 -> 创建请求和响应对象 -> request,response
    • Web容器 -> 调用servlet方法 -> Servlet.service(req,resp)
    • service(req,resp)获取请求信息,并把响应写入响应信息返回给Web容器
    • Web容器 -> 发出Http响应 -> Web浏览器

    Servlet与JSP关系

    在这里插入图片描述

    Servlet生命周期

    Servlet生命周期
    在这里插入图片描述
    对Servlet的生命周期的三个阶段进行详细介绍:

    初始化阶段

    服务器会在客户端第一次访问Servlet,或服务器启动的时候为该Servlet创建实例。要想在服务器启动的时候就为Servlet创建实例,需要在web.xml中进行配置。当服务器为Servlet创建实例后,会在第一时间调用init()方法,完成Servlet的初始化操作。注意这个init()方法在Servlet的一生中,只会被服务器调用一次。

    服务阶段

    当服务器接收到请求时,会去调用Servlet的service()方法来处理请求,而且每次请求的时候,服务器都会调用service()方法,并且创建新的ServletRequest和ServletResponse对象,所以该方法在Servlet的一生中会被调用多次。

    销毁阶段

    当服务器关闭或者当前web应用被移出服务器时,Servlet会被销毁,在销毁之前,服务器会调用destroy()方法,可以把Servlet的“临终遗言“放在该方法中,例如把对某些资源的释放等代码放在destroy()方法中。

    /8

    Servlet实现类

    Servlet接口被SUN公司定义了两个默认实现类,分别为:GenericServletHttpServlet

    • HttpServlet指能够处理HTTP请求的servlet,它在原有Servlet接口上添加了一些与HTTP协议处理方法,它比Servlet接口的功能更为强大,因此开发人员在编写Servlet时,通常应继承这个类,而避免直接去实现Servlet接口
    • HttpServlet在实现Servlet接口时,覆写了service方法,该方法体内的代码会自动判断用户的请求方式,如为GET请求,则调用HttpServlet的doGet方法,如为Post请求,则调用doPost方法,因此,开发人员在编写Servlet时,通常只需要覆写doGet或doPost方法,而不要去覆写service方法

    Servlet创建

    Servlet创建三种思路

    • 创建类实现javax.servlet.Servlet接口
    • 创建类继承javax.servlet.GenericServlet类
    • 创建类继承javax.servlet.http.HttpServlet类

    在src目录下新建Servlet,如图所示
    在这里插入图片描述
    导入Servlet需要的jar包(Alt + 回车键 到标红线的代码可以自动下载缺失的jar包),jar包如图所示:
    在这里插入图片描述
    新建Servlet之后,会出现一个新的java文件,代码如下所示:

    package servlet;
    
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class ServletTest01 extends javax.servlet.http.HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
            
        }
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
    
        }
    }
    

    在web.xml文件中,会多出一个Servlet标签,代码如下所示:

    <?xml version="1.0" encoding="UTF-8"?>
    <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
             version="4.0">
    
        <servlet>
            <servlet-name>ServletTest01</servlet-name>
            <servlet-class>servlet.ServletTest01</servlet-class>
        </servlet>
    	
    	<!--一般默认不会创建servlet-mapping标签,不过要使用servlet,就需要使用与servlet属性相同的servlet-mapping映射-->
    	<servlet-mapping>
            <servlet-name>ServletTest01</servlet-name>
            <url-pattern>/test01</url-pattern>
        </servlet-mapping>
        
    </web-app>
    

    这样,一个Servlet就创建完成了。

    Servlet映射路径问题

    一般情况下我们都会制定一个URL,一个URL对应一个请求

    通配问题:

    • /* : 不报错,*代表任意的信息
    • /*.do:报错,程序会认为/*是一个整体,而.do就不认识了
    • *.do:不报错,*代表任意的信息,但是 .do是必要的

    Servlet重定向

    将这个请求,转换到另一个地址。
    例如,我们请求 http://localhost:8080/javaweb/ServletTest01 却跳转到了 百度的首页,代码如下(ServletTest01对应的请求URL在web.xml提前设置好):

    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    import java.io.PrintWriter;
    
    @WebServlet(name = "ServletTest01")
    public class ServletTest01 extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		
        }
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        	response.sendRedirect("https://www.baidu.com/");
        }
    }
    

    ServletContext类

    Web容器在启动时,它会为每个WEB应用程序都创建一个对应的ServletContext对象,它代表当前的WEB应用。

    ServletContext类,作用如下:

    • 多个Servlet通过ServletContext对象实现数据共享
    • 获取WEB应用的初始化参数
    • 用servletContext实现请求转发
    • 利用ServletContext对象读取资源文件

    假设有一个名为ServletDemo01的Servlet,要传输一个键为name而值为abc的数据给ServletDemo02,代码如下:

    ServletDemo01

    import javax.servlet.ServletContext;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class ServletDemo01 extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
            doGet(request,response);
        }
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws javax.servlet.ServletException, IOException {
            // 通过servlet对象,可以获取一个servletContext;
            response.setCharacterEncoding("gbk");
            ServletContext servletContext = this.getServletContext();
            String username = "abc"; // 可以通过JDBC去读取;
            // setAttribute:设置一个属性;(属性名,属性值)
            servletContext.setAttribute("name",username);
            response.getWriter().print("设置信息成功!" + username);
        }
    }
    

    ServletDemo02

    import javax.servlet.ServletContext;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.IOException;
    
    public class ServletDemo02 extends HttpServlet {
        protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            ServletContext servletContext = this.getServletContext();
            String name = (String) servletContext.getAttribute("name");
            response.setCharacterEncoding("gbk");
            response.getWriter().print("获取到的信息为:" + name );
        }
    
        protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
            doPost(request,response);
        }
    }
    

    示例图如下:
    在这里插入图片描述

    通过ServletContext对象读取网站配置文件

    1.在项目src目录下新建resources目录,在该目录下新建一个properties文件,如下所示

    driver=com.mysql.jdbc.Driver
    username=root
    password=123456
    url=jdbc:mysql://localhost:3306/smbms
    

    2.编写Servlet类

    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.util.Properties;
    
    //读取properties配置文件
    public class ServletDemo03 extends HttpServlet {
    
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //读取配置文件
    
            //1.获得配置文件的路径
            String realPath = this.getServletContext().getRealPath("/WEB-INF/classes/resources/database.properties");
            System.out.println("取得的路径为:"+realPath);
    
            Properties properties = new Properties();
            FileInputStream is = new FileInputStream(realPath);
    
            properties.load(is);//把文件流加载到配置文件的对象中;
    
            String driver = properties.getProperty("driver");
            String username = properties.getProperty("username");
            String password = properties.getProperty("password");
            String url = properties.getProperty("url");
    
    
            //响应到网页
            resp.getWriter().println(driver);
            resp.getWriter().println(username);
            resp.getWriter().println(password);
            resp.getWriter().println(url);
    
            //=======================================
            System.out.println(driver);
            System.out.println(username);
            System.out.println(password);
            System.out.println(url);
        }
    }
    

    3.配置web.xml

    <servlet>
        <servlet-name>Demo03</servlet-name>
        <servlet-class>com.servlet.ServletDemo03</servlet-class>
    </servlet>
    
    <servlet-mapping>
        <servlet-name>Demo03</servlet-name>
        <url-pattern>/ccc</url-pattern>
    </servlet-mapping>
    

    4.访问查看

    在页面的链接栏中输入 localhost:8080/demo02/ccc,可以查看到如下页面:

    在这里插入图片描述

    简单验证码应用

    设置一个六位数的随机数作为验证码,每次刷新时验证码都会发生变换,代码如下:

    import javax.imageio.ImageIO;
    import javax.servlet.ServletException;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    import java.awt.*;
    import java.awt.image.BufferedImage;
    import java.io.IOException;
    import java.util.Map;
    
    //验证码
    public class ServletDemo04 extends HttpServlet {
        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            doPost(req,resp);
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    
            //resp.getWriter().println(newRandom());
    
            //自动刷新网页
            resp.setHeader("refresh","2");
            //验证码是一个图片 , 我们需要制作一个图片
            BufferedImage image = new BufferedImage(100,30,BufferedImage.TYPE_3BYTE_BGR);
    
            //图片写入一些东西
            Graphics2D graphics = image.createGraphics();
            graphics.setColor(Color.red);
            String num = String.valueOf(newRandom());
            graphics.drawString(num,10,10);
    
            //想办法让浏览器知道我们给的是一张图片
            resp.setContentType("image/jpg");
    
            //让网站去打开图片
            ImageIO.write(image,"jpg",resp.getOutputStream());
    
        }
    
    
        //生成随机数
        public int newRandom(){
            int num = (int)(Math.random()*9+1)*100000;
            return num;
        }
    
        /*
        @Test
        public void  test(){
            ServletDemo04 servletDemo04 = new ServletDemo04();
    
            for (int j = 0; j < 100; j++) {
                int i = servletDemo04.newRandom();
                System.out.println(i);
            }
        }
        */
    }
    
    展开全文
  • Servlet总结

    2018-09-25 14:18:53
    Servlet整理 响应体以流的形式,向客户端做出响应,里面包括数据。其实请求转发和重定向都是以字符流的形式,向浏览器返回的是一个contentType为text/html页面类型格式的数据,其实还有其他的格式的数据,让浏览器...
  • Eclipse+Tomcat7.0(jre.8)的WAR部署到WebSphere8.5的时候报错 [img=https://img-bbs.csdn.net/upload/201508/28/1440729214_53074.png][/img] [color=#FF0000]Messages ErrorWebQuery_war failed to ...
  • java servlet

    千次阅读 2010-03-19 22:45:00
    Java Servlet动态网页是指在不同的时刻,和不同的情况下从服务器端返回的页面内容是不同的,变化的,它的解析执行是在服务器端完成的。动态html是指依赖浏览器对页面脚本内容进行解析,生成不同的页面,但是从服务器...
  • servlet类: import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.image.BufferedImage; import java.awt.image.RenderedImage; import java.io.IOException; import java....
  • 我需要在哪儿下载什么吗?下载后又该怎么操作呢?谢谢大家! <br />解答: 就用tomcat的那个servlet-api.jar就成。 下载好后设置一下build path.. 或直接装个插件比如myeclipse,你建WEB项目...
  • 其实Servlet本身在Tomcat中是“非常被动”的一个角色,处理的事情也很简单。网络请求与响应,不是他的主要职责,它其实更偏向于业务代码。所谓的Request和Response是Tomcat传给它,用来处理请求和响应的工具,但它...
  • Servlet工作原理

    2012-09-29 13:48:11
    Servlet运行在Servlet容器中,由容器负责Servlet实例的查找及创建工作,并按照Servlet规范的规定调用Servlet的一组方法,这些方法也叫生命周期的方法。具体调用过程如下图所示: Servlet生命周期详解  如上图所...
  • 在写javaweb项目,使用的是jsp+servlet 但是在IDEA中创建好项目后,在搭建结构的时候,创建servlet文件去没有选项。...然后勾上 servlet-api那个 点击ok 可以了 个人博客网站 : lczze.cn 欢迎个 来发博客 ...
  • servlet总结

    2014-07-22 21:55:27
    java->servlet->jsp [技术总是有一个演变过程] zip粘贴到word设置 u 回顾一下我们现有的技术   java 基础(面向对象,集合,界面,线程,文件,网络) jdbc (java 的数据库编程) oracle / mysql / sqlserver ...
  • JavaEE中servlet的应用

    2020-07-22 22:51:44
    Servlet可以简单的理解Java里的一个接口。 1.servlet是服务器中核心处理单元 2.服务器中有多个不同的servlet,每一个servlet负责不同的业务,处理不同的请求 3.servlet的对象创建和调用其方法,都是tomcat来完成的...
  • WEB-Servlet

    2017-02-14 00:42:26
    WEB-Servlet 1.1 案例一:使用Servlet完成一个用户登录的案例. 1.1.1 需求: 在网站的首页上,登录的链接,点击登录的链接,可以跳转到登录的页面.在登录的页面中输入用户名和密码点击登录的案例.完成登录的功能. ...
  • 前面几间讲了servet的产生环境、servlet容器概念、jsp的产生背景,现在本章进入实操,使用idea建立一个简单的servlet。 一、环境说明 1.1开发环境 名称 版本 安装方式 ...
  • Servlet笔记

    千次阅读 2013-08-28 13:42:04
    java->servlet->jsp [技术总是有一个演变过程] zip粘贴到word设置 u 回顾一下我们现有的技术   java 基础(面向对象,集合,界面,线程,文件,网络) jdbc (java 的数据库编程) oracle / mysql / sqlserver ...
  • 前台和后台的区别 前台:呈现给用户的视觉和基本的操作。 后台:用户浏览网页时,我们看不见的后台...Servlet是一个基于java技术的Web-APi,运行在服务器端,由servlet容器管理,用于生成动态内容。 Tomcat 介绍 Tom
  • Servlet其实就是一个遵循Servlet开发的java类。Serlvet是由服务器调用的,运行在服务器端。为什么要用到Serlvet?我们编写java程序想要在网上实现 聊天、发帖、这样一些的交互功能,普通的java技术是非常难完成的。...
  • eclipse创建servlet项目详细步骤

    万次阅读 多人点赞 2018-07-25 22:37:30
    需要使用到的环境,jdk 1.80 ,tomcat 8.0 /64  首先将eclipse绑定jdk, 然后, 点击finish即可完成jdk的绑定。然后开始创建项目: 下一步, 下一步, 下一步,创建一个 创建一个servlet类...
  • 我们以Apache Tomcat作为Servlet/JSP的Web容器;  1) Oracle JDK;  2) Eclipse Jave EE企业版;  3) Apache Tomcat; !!所有的这些组件要么全部都用32要么全部都用64; !建议都是用32的,因为Eclipse...
  • 无论这个数据有多大,它的指纹都是固定的128,即16个字节 * @see 我们可以使用Java中提供的java.security.MessageDigest工具类,得到随机数的数据摘要,即数据指纹 * @see ====================================...
  • 请教 webdav-servlet

    2008-11-13 08:57:47
    下了几个 webdav-servlet-1.2.jar webdav-servlet-1.2.war webdav-servlet-1.2-bundle.jar webdav-servlet-1.2-sources.jar 怎么搭建webdav ?给点指点。有哪人兄用过给些指导 谢谢
  • servlet+jsp实现登录控制

    千次阅读 2018-05-29 16:22:07
    1、新建一个工程,取名后点击next2、勾选,finfish建好工程后,需要建servlet和jsp了3、建一个servlet取好名和servlet名,点next4、删除/servlet,也可不删,然后finish5、新建一个jsp最后一共有两个servlet,4个jsp...
  • 本项目通过使用jsp和servlet实现简单的用户登录。主要逻辑为: 如果用户不存在,则首先进行注册(注册信息同步到数据库中)。 进行注册后,可进入登录页面对账号进行登录。 如果账号存在,则正确跳转到欢迎界面,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 43,237
精华内容 17,294
关键字:

servlet的包位