? 简介
? Web 开发基础

–B/S结构程序
–请求响应机制
–HTML
–Servlet
–JSP
–Web 服务器

? 编程思想
–分层开发思想
–面向接口编程思想

? 设计模式
–DAO设计模式
–MVC设计模式
----------------------------Start---------------------------------------
? 简介
–因为Struts是Servlet+JSP的MVC解决方案,所以在学习Struts之前有必要了解如下Web开发的基础知识,使用Servlet+JSP如何编程,以及编程思想和设计模式中Web开发中应用
? 这对我们在学习Struts时是很有帮助的
? 我们要比较Servlet+JSP程序的MVC模式实现和Struts MVC的异同
? Servlet+JSP程序的弊端
? Struts的优势
? 程序开发的思想
? 设计模式的应用
? Web 开发基础
– B/S结构程序

? B/S结果程序是指,基于Browser(浏览器)/Server(服务器)的应用程序
? 相对C/S结构程序而言,B/S结构程序有如下优点:
– 基于网络
– 共享性好
– 客户端零维护
– 请求响应机制
? B/S程序的主要特征是请求(request)响应(response)机制
? 通常使用的协议是Http协议,该协议是无状态的
– HTML
? HTML的全称是Hyper Text Markup Language(超文本标记语言)
?基本结构是:
<HTML>
<HEAD>
<title>, <base>, <link>,  <meta>
</HEAD>
<BODY>
HTML 文件的正文写在这里... ...
</BODY>
</HTML>
– Servlet
? Servlet 是为动态创建Web工程而提供的编程接口
MyServlet.java
image
web.xml
设置servlet的申明和映射
image
测试:
image
– JSP
? 为了解决Servlet的开发效率问题而设计的开发语言
? 底层执行还是Servlet
image image MyJsp_jsp.java
package org.apache.jsp;    

import javax.servlet.*;    
import javax.servlet.http.*;    
import javax.servlet.jsp.*;    
import java.util.*;    

public final class MyJsp_jsp extends org.apache.jasper.runtime.HttpJspBase    
        implements org.apache.jasper.runtime.JspSourceDependent {    

    private static final JspFactory _jspxFactory = JspFactory.getDefaultFactory();    

    private static java.util.List _jspx_dependants;    

    private javax.el.ExpressionFactory _el_expressionfactory;    
    private org.apache.AnnotationProcessor _jsp_annotationprocessor;    

    public Object getDependants() {    
        return _jspx_dependants;    
    }    

    public void _jspInit() {    
        _el_expressionfactory = _jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();    
        _jsp_annotationprocessor = (org.apache.AnnotationProcessor) getServletConfig().getServletContext().getAttribute(org.apache.AnnotationProcessor.class.getName());    
    }    

    public void _jspDestroy() {    
    }    

    public void _jspService(HttpServletRequest request, HttpServletResponse response)    
                throws java.io.IOException, ServletException {    

        PageContext pageContext = null;    
        HttpSession session = null;    
        ServletContext application = null;    
        ServletConfig config = null;    
        JspWriter out = null;    
        Object page = this;    
        JspWriter _jspx_out = null;    
        PageContext _jspx_page_context = null;    

        try {    
            response.setContentType("text/html;charset=ISO-8859-1");    
            pageContext = _jspxFactory.getPageContext(this, request, response,    
                                    null, true, 8192, true);    
            _jspx_page_context = pageContext;    
            application = pageContext.getServletContext();    
            config = pageContext.getServletConfig();    
            session = pageContext.getSession();    
            out = pageContext.getOut();    
            _jspx_out = out;    

            out.write('\r');    
            out.write('\n');    

String path = request.getContextPath();    
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";    

            out.write("\r\n");    
            out.write("\r\n");    
            out.write("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">\r\n");    
            out.write("<html>\r\n");    
            out.write("    <head>\r\n");    
            out.write("        <base href=\"");    
            out.print(basePath);    
            out.write("\">\r\n");    
            out.write("        \r\n");    
            out.write("        <title>My JSP 'MyJsp.jsp' starting page</title>\r\n");    
            out.write("        \r\n");    
            out.write("\t<meta http-equiv=\"pragma\" content=\"no-cache\">\r\n");    
            out.write("\t<meta http-equiv=\"cache-control\" content=\"no-cache\">\r\n");    
            out.write("\t<meta http-equiv=\"expires\" content=\"0\">        \r\n");    
            out.write("\t<meta http-equiv=\"keywords\" content=\"keyword1,keyword2,keyword3\">\r\n");    
            out.write("\t<meta http-equiv=\"description\" content=\"This is my page\">\r\n");    
            out.write("\t<!--\r\n");    
            out.write("\t<link rel=\"stylesheet\" type=\"text/css\" href=\"styles.css\">\r\n");    
            out.write("\t-->\r\n");    
            out.write("\r\n");    
            out.write("    </head>\r\n");    
            out.write("    \r\n");    
            out.write("    <body>\r\n");    
            out.write("        This is my JSP page. <br>\r\n");    
            out.write("    </body>\r\n");    
            out.write("</html>\r\n");    
        } catch (Throwable t) {    
            if (!(t instanceof SkipPageException)){    
                out = _jspx_out;    
                if (out != null && out.getBufferSize() != 0)    
                    try { out.clearBuffer(); } catch (java.io.IOException e) {}    
                if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);    
            }    
        } finally {    
            _jspxFactory.releasePageContext(_jspx_page_context);    
        }    
    }    
}


– Web 服务器
? Web工程的运行容器,如Tomcat
image
image
? 编程思想
–分层开发思想
? 软件的层次结构可以分为四层:
–表现层
–控制层
–业务逻辑层
–数据逻辑层(持久层)
–面向接口编程思想
? 在编程中将业务逻辑抽象出接口,以供上次调用
? 依赖抽象(接口),而非具体(接口实现)的编程思想,又称之为控制反转(Inversion of Control)
 
? 设计模式
–DAO设计模式
? DAO设计模式
–DAO的全称是:Data Access Object,数据访问对象。
–使用DAO设计模式,来封装数据库持久层的所有操作(CRUD),使低级的数据逻辑和高级的业务逻辑分离,达到解耦合的目的。
? 一个典型的DAO实现有如下的组件:
–一个 DAO 接口
–一个实现了 DAO 接口的具体类
–一个 DAO 工厂类
–数据传输对象(有时称为值对象)
?以维护一个客户信息为例,具体组件如下所示:
–CustomerDao 接口
–Customer 值对象(VO)
–CustomerDaoImpl(接口的具体实现类)
–CustomerFactory(工厂类,实例化用)
–MVC设计模式
? MVC的全称是:Model(模型) View(视图) Controller( 控制器)
? Model
–对应业务逻辑层、数据逻辑层
–由接口及其实现类充当
? View
–对应表现层
–由HTML页面、JSP页面、Tag(标签)等充当
? Controller
–对应控制层
–由Servlet 或Struts中的Action等充当
 
? 编程思想和设计模式的具体应用
–图示
自定义MVC
image_thumb31
 
?实例
–以添加客户和查询客户列表为例来说明上述内容
–程序运行结果
image
数据库设置 image
CustomerDao.java
 image
CustomerDaoImpl.java
package com.redking.dao.impl;    

import java.sql.Connection;    
import java.sql.PreparedStatement;    
import java.sql.ResultSet;    
import java.sql.SQLException;    
import java.sql.Statement;    
import java.util.ArrayList;    
import java.util.List;    

import com.redking.dao.CustomerDao;    
import com.redking.util.ConnectionUtil;    
import com.redking.util.SQLConstants;    
import com.redking.vo.Customer;    

public class CustomerDaoImpl implements CustomerDao,SQLConstants{    

        public List listCustomer() {    
                ConnectionUtil cu = new ConnectionUtil();    
                Connection conn = cu.getConnection();    
                //conn.setAutoCommit(false);设置默认不自动提交    
                //Statement stmt;静态添加    
                //PrepareStatement pstmt;动态添加    
                List list = new ArrayList();    
                try {    
                        Statement stmt = conn.createStatement();    
                        ResultSet rs = stmt.executeQuery(QUERY_CUSTOMER_SQL);    
                        while(rs.next()){    
                                int id = rs.getInt(1);    
                                String name = rs.getString(2);    
                                String email = rs.getString(3);    
                                Customer c = new Customer();    
                                c.setId(id);    
                                c.setName(name);    
                                c.setEmail(email);    
                                list.add(c);    
                        }    
                        return list;    
                } catch (SQLException e) {    
                        e.printStackTrace();    
                }finally{    
                        try {    
                                conn.close();    
                        } catch (SQLException e) {    
                                e.printStackTrace();    
                        }    
                }    
                return null;    
        }    

        public void save(Customer c) {    
                ConnectionUtil cu = new ConnectionUtil();    
                Connection conn = cu.getConnection();    
                //conn.setAutoCommit(false);设置默认不自动提交    
                //Statement stmt;静态添加    
                //PrepareStatement pstmt;动态添加    
                PreparedStatement pstmt = null;    
                try {    
                        pstmt = conn.prepareStatement(ADD_CUSTOMER_SQL);    
                        pstmt.setString(1, c.getName());    
                        pstmt.setString(2, c.getEmail());    
                        pstmt.executeUpdate();    
                        //conn.commit();设置强制提交    
                } catch (SQLException e) {    
                        e.printStackTrace();    
                }finally{    
                        try {    
                                conn.close();    
                        } catch (SQLException e) {    
                                e.printStackTrace();    
                        }    
                }    
        }    

}

CustomerServlet.java
package com.redking.servlet;    

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 com.redking.dao.CustomerDao;    
import com.redking.dao.impl.CustomerDaoImpl;    
import com.redking.vo.Customer;    

public class CustomerServlet extends HttpServlet {    

        /**    
         * Constructor of the object.    
         */
    
        public CustomerServlet() {    
                super();    
        }    

        /**    
         * Destruction of the servlet. <br>    
         */
    
        public void destroy() {    
                super.destroy(); // Just puts "destroy" string in log    
                // Put your code here    
        }    

        /**    
         * The doGet method of the servlet. <br>    
         *    
         * This method is called when a form has its tag value method equals to get.    
         *    
         * @param request the request send by the client to the server    
         * @param response the response send by the server to the client    
         * @throws ServletException if an error occurred    
         * @throws IOException if an error occurred    
         */
    
        public void doGet(HttpServletRequest request, HttpServletResponse response)    
                        throws ServletException, IOException {    
                doPost(request,response);    
        }    

        /**    
         * The doPost method of the servlet. <br>    
         *    
         * This method is called when a form has its tag value method equals to post.    
         *    
         * @param request the request send by the client to the server    
         * @param response the response send by the server to the client    
         * @throws ServletException if an error occurred    
         * @throws IOException if an error occurred    
         */
    
        public void doPost(HttpServletRequest request, HttpServletResponse response)    
                        throws ServletException, IOException {    
                /*    
                //响应用户请求    
                String name = request.getParameter("name");    
                String email = request.getParameter("email");    
                //调用后台逻辑-dao    
                CustomerDao dao = new CustomerDaoImpl();    
                Customer c = new Customer();    
                c.setName(name);    
                c.setEmail(email);    
                dao.save(c);    
                //跳转其他页面    
                //RequestDispatcher    
                request.getRequestDispatcher("/pages/Customer.jsp").forward(request,response);    
                */
    
                String methodName = request.getParameter("methodName");    
                if(methodName!=null&&methodName.equals("save")){    
                        save(request,response);    
                }else{    
                        list(request,response);    
                }    
        }    
        public void save(HttpServletRequest request, HttpServletResponse response)    
        throws ServletException, IOException {    

                //响应用户请求    
                String name = request.getParameter("name");    
                String email = request.getParameter("email");    
                //调用后台逻辑-dao    
                CustomerDao dao = new CustomerDaoImpl();    
                Customer c = new Customer();    
                c.setName(name);    
                c.setEmail(email);    
                dao.save(c);    
                //跳转其他页面    
                //RequestDispatcher    
                //request.getRequestDispatcher("/pages/Customer.jsp").forward(request,response);    
                list(request,response);    
        }    
        public void list(HttpServletRequest request, HttpServletResponse response)    
        throws ServletException, IOException {    

                //响应用户请求    
                String name = request.getParameter("name");    
                String email = request.getParameter("email");    
                //调用后台逻辑-dao    
                CustomerDao dao = new CustomerDaoImpl();    
                List list = dao.listCustomer();    
                request.setAttribute("CustomerList", list);    
                //跳转其他页面    
                //RequestDispatcher    
                request.getRequestDispatcher("/pages/Customer.jsp").forward(request,response);    
        }    

        /**    
         * Initialization of the servlet. <br>    
         *    
         * @throws ServletException if an error occurs    
         */
    
        public void init() throws ServletException {    
                // Put your code here    
        }    

}
ConnectionUtilTest.java
image
CustomerDaoImplTest.java
image
ConnectionUtil.java
image
 SQLConstants.java
image
Customer.java
image
DBConfig.properties
image
Customer.jsp
image 
<%@ page language="java" import="java.util.*,com.redking.vo.*" pageEncoding="gbk"%>    
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="redking" %>    
<%    
String path = request.getContextPath();    
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";    
%>    

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">    
<html>    
    <head>    
        <base href="<%=basePath%>">    
        <title>My JSP 'Customer.jsp' starting page</title>    
        <meta http-equiv="pragma" content="no-cache">    
        <meta http-equiv="cache-control" content="no-cache">    
        <meta http-equiv="expires" content="0">        
        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">    
        <meta http-equiv="description" content="This is my page">    
        <!--    
        <link rel="stylesheet" type="text/css" href="styles.css">    
        -->    

    </head>    
    <body>    
        <form name="f1" id="f1" action="<%=path %>/servlet/CustomerServlet?methodName=save" method="post">    
            <table border="0">    
                <tr>    
                    <td>Name:</td>    
                    <td><input type="text" name="name" ></td>    
                </tr>    
                <tr>    
                    <td>Email:</td>    
                    <td><input type="text" name="email" ></td>    
                </tr>    
                <tr>    
                    <td colspan="2" align="center"><input type="submit" value="保存"></td>    
                </tr>    
            </table>    
        </form>    
        <hr>    
        <table>    
        <tr><th>ID</th><th>Name</th><th>Email</th></tr>    
        <%--    
        <%    
                List list = (List) request.getAttribute("CustomerList");    
                //遍列LIST    
                for(int i=0;i<list.size();i++){    
                        Customer c = (Customer) list.get(i);    
                        out.println("<tr>");    
                        out.println("<td>");    
                        out.println(c.getId());    
                        out.println("</td>");    
                        out.println("<td>");    
                        out.println(c.getName());    
                        out.println("</td>");    
                        out.println("<td>");    
                        out.println(c.getEmail());    
                        out.println("</td>");    
                        out.println("</tr>");    
                }    
         %>    
            --%>    
            <%--使用标准标签 --%>    
            <redking:forEach var="c" items="${CustomerList}">    
                    <tr>    
                            <td>    
                                    ${c.id }    
                            </td>    
                            <td>    
                                    ${c.name }    
                            </td>    
                            <td>    
                                    ${c.email }    
                            </td>    
                    </tr>    
            </redking:forEach>    
        </table>    
    </body>    
</html>

测试:
image
image image
image 
----------------------------------END-------------------------------------