整合营销服务商

电脑端+手机端+微信端=数据同步管理

免费咨询热线:

「java就业班」2019从网页搭建入门JavaWe

「java就业班」2019从网页搭建入门JavaWeb

java就业班」2019从网页搭建入门JavaWeb

来百度APP畅享高清图片

//下栽のke:chaoxingit.com/1534/

从网页搭建入门到JavaWeb:2019版详解

一、引言

随着互联网技术的飞速发展,JavaWeb已经成为了一种非常流行的开发技术。通过JavaWeb,我们可以快速地构建出功能强大、安全可靠的Web应用程序。本文将详细介绍如何从网页搭建入门到JavaWeb,帮助你掌握这门技术。

二、JavaWeb简介

JavaWeb指的是使用Java技术开发的Web应用程序。它是基于Java平台的一种开发模式,用于构建和部署在Web服务器上运行的应用程序。JavaWeb通常涉及以下关键组件和技术:

  1. Servlet: Servlet是Java编写的服务器端程序,主要用于处理HTTP请求和生成HTTP响应。它们运行在支持Servlet规范的Web服务器上,如Apache Tomcat、Jetty等。
  2. JSP(JavaServer Pages): JSP是一种服务器端的Java技术,用于创建动态Web页面。JSP页面可以包含HTML、Java代码片段和JSP标签库,它们会在服务器端被解析和执行,最终生成HTML响应发送给客户端。
  3. Servlet容器: Servlet容器是一个Web服务器组件,用于管理和执行Servlet。它负责将HTTP请求路由到相应的Servlet,并将Servlet生成的响应发送回客户端。
  4. JDBC(Java Database Connectivity): JDBC是Java提供的用于与数据库交互的API。它允许Java应用程序通过标准的数据库操作语句与各种关系型数据库进行通信。
  5. Web容器: Web容器是一种用于托管和运行Web应用程序的环境。它提供了Servlet容器、JSP引擎以及其他必要的组件,使得开发者可以部署和管理JavaWeb应用程序。
  6. MVC架构(Model-View-Controller): MVC是一种常用的设计模式,用于将应用程序分为三个核心部分:模型(Model)、视图(View)和控制器(Controller)。在JavaWeb开发中,开发者通常使用MVC架构来组织和管理应用程序的代码。
  7. Web框架: JavaWeb开发中常用的框架包括Spring MVC、Struts、JSF(JavaServer Faces)等。这些框架提供了各种功能和工具,简化了开发过程,并提高了代码的可维护性和可扩展性。

JavaWeb应用程序通常遵循HTTP协议,与客户端通过HTTP请求和响应进行通信。它们可以处理各种类型的请求,包括GET、POST等,并能够生成动态内容以及与数据库等外部资源进行交互。 JavaWeb的发展已经成为构建企业级应用程序的主流方式之一,它提供了强大的功能和丰富的生态系统,使得开发者能够构建高性能、可靠和安全的Web应用程序。

三、学习资源

要想入门JavaWeb,你可以选择以下学习资源:

  1. 官方文档:Java官方文档提供了丰富的JavaWeb学习资源,包括API文档、框架文档和教程等。
  2. 培训课程:网络上有很多免费的JavaWeb培训课程,这些课程可以帮助你快速入门。
  3. 书籍:阅读一些经典的JavaWeb书籍,如《Head First Servlets and JavaServer Pages》等,可以帮助你深入理解JavaWeb技术。

四、搭建开发环境

搭建JavaWeb开发环境涉及到几个主要组件,包括Java Development Kit (JDK)、集成开发环境(IDE)、Servlet容器等。以下是从头开始搭建JavaWeb开发环境的步骤:

  1. 安装Java Development Kit (JDK):
  • 首先,你需要安装Java Development Kit,它包含了Java编译器(javac)和Java运行时环境(JRE)。
  • 前往Oracle JDK官网或OpenJDK官网下载并安装最新版本的JDK。
  • 设置JAVA_HOME环境变量,指向你的JDK安装目录。
  • 安装集成开发环境(IDE):
    • 选择一个JavaWeb开发的IDE。Eclipse、IntelliJ IDEA和NetBeans是常见的选择。
    • 下载并安装你选择的IDE。例如,你可以在IntelliJ IDEA官网下载IntelliJ IDEA。
  • 安装Servlet容器:
    • 选择一个Servlet容器,例如Apache Tomcat。
    • 前往Apache Tomcat官网下载最新版本的Tomcat。
    • 解压下载的文件到你想要安装的目录。
  • 创建JavaWeb项目:
    • 打开你的IDE,创建一个新的JavaWeb项目。
    • 在项目中配置Servlet容器,以便在开发过程中能够轻松部署和调试。
  • 编写第一个Servlet:
    • 在项目中创建一个Servlet类,这是JavaWeb应用程序的基本处理单元。
    • 实现doGet和/或doPost方法,用于处理HTTP请求和生成HTTP响应。
  • 配置Servlet容器:
    • 配置Servlet容器,告诉它在哪里找到你的Web应用程序。
    • 在Tomcat中,你需要配置server.xml文件,添加一个新的<Context>元素,指向你的项目目录。
  • 部署和运行:
    • 将你的JavaWeb项目部署到Servlet容器中。
    • 启动Servlet容器,查看你的JavaWeb应用程序是否成功运行。
  • 学习HTML和基本前端知识:
    • JavaWeb开发通常涉及与前端进行交互,因此学习HTML和基本的前端知识对于构建用户界面是很有帮助的。

    在完成上述步骤后,你就建立了一个基本的JavaWeb开发环境,并且能够开始编写和部署简单的Web应用程序。从这里开始,你可以深入学习JavaWeb的各个方面,包括Servlet、JSP、数据库连接等,以构建更复杂和功能丰富的Web应用程序。

    五、网页搭建基础

    网页搭建是学习JavaWeb的基础,主要包括HTML、CSS和JavaScript等基础知识。通过学习这些基础知识,你可以快速搭建出基本的网页。

    六、JavaWeb核心技术

    JavaWeb 是使用 Java 技术进行 Web 开发的一种方式,它涵盖了多个核心技术和框架。以下是 JavaWeb 的一些核心技术:

    1. Servlet:
    • Servlet 是运行在服务器端的 Java 应用程序,主要用于处理客户端的请求并生成响应。
    • Servlet 继承自 javax.servlet.Servlet 接口,通过覆盖 doGet 和 doPost 等方法来处理不同类型的 HTTP 请求。
  • JSP (JavaServer Pages):
    • JSP 允许在 HTML 页面中嵌入 Java 代码,它最终会被翻译成 Servlet。
    • JSP 提供了简化开发的方式,允许开发人员在页面中使用标签库来调用 JavaBean 等组件。
  • Servlet容器:
    • Servlet 容器是一个 Web 服务器或应用服务器组件,负责管理 Servlet 的生命周期、请求和响应。
    • 常见的 Servlet 容器包括 Apache Tomcat、Jetty 和 WildFly。
  • JavaBeans:
    • JavaBeans 是一种可重用的 Java 组件,通常用于在 Web 应用程序中封装数据和业务逻辑。
    • 在 JavaWeb 中,JavaBeans 可以被用于从数据库中获取数据、在页面中展示数据等任务。
  • JDBC (Java Database Connectivity):
    • JDBC 是 Java 用于与数据库进行交互的 API。
    • 在 JavaWeb 开发中,使用 JDBC 可以连接数据库、执行 SQL 查询和更新等操作。
  • JPA (Java Persistence API):
    • JPA 是 Java 用于对象关系映射(ORM)的 API,简化了 Java 对象与数据库表之间的映射。
    • Hibernate、EclipseLink 等框架实现了 JPA 规范,使得持久化操作更加方便。
  • Spring框架:
    • Spring 是一个综合性的 Java 开发框架,提供了依赖注入、面向切面编程、事务管理等功能。
    • Spring 的模块中有 Spring MVC 用于构建 Web 应用,Spring Boot 则简化了 Spring 应用程序的搭建。
  • Struts框架:
    • Struts 是一个基于 MVC 模式的 Web 应用框架,用于简化开发复杂的 Web 应用程序。
    • Struts 的核心是一个控制器,负责接收用户请求,并将其分发给相应的处理器(Action)。
  • Web Services:
    • JavaWeb 中常用的 Web 服务技术包括 SOAP(Simple Object Access Protocol)和 REST(Representational State Transfer)。
    • JAX-RS(Java API for RESTful Web Services)是 Java EE 中用于构建 RESTful Web 服务的 API。
  • Security:
    • JavaWeb 应用程序的安全性是至关重要的。Java 提供了一些安全机制,例如 Java Authentication and Authorization Service (JAAS) 和 Java Security Architecture。

    以上是 JavaWeb 的一些核心技术,这些技术一起构成了一个完整的 JavaWeb 开发生态系统。开发人员可以根据项目需求选择适当的技术和框架来构建稳健、高效的 Web 应用程序。

    七、实践项目

    实践项目是学习JavaWeb的重要环节,你可以选择以下项目进行实践:

    1. 创建一个简单的Web应用程序,包括用户注册、登录和信息展示等功能;
    2. 实现一个博客网站,包括文章列表、评论和发布等功能;
    3. 与第三方API进行交互,实现一个基于API的移动应用程序。

    通过实践项目,你可以更好地掌握JavaWeb技术,并提高自己的编程能力和团队协作能力。

    八、总结与展望

    通过本文的介绍,相信你已经对从网页搭建入门到JavaWeb有了更深入的了解。要想成为一名优秀的JavaWeb开发者,你需要不断学习、实践和总结。同时,随着技术的不断发展,你需要不断关注新技术和趋势,并努力提升自己的技能水平。希望本文能够帮助你成功迈向后端工程师的高阶之路!

    .把JSP页面放在WEB-INF目录下,存放在此目录或者它的子目录里的任何东西都受到了保护。

    2.使用servlet过滤器过滤对jsp页面的请求。

    import	javax.servlet.*;	
    import javax.servlet.http.HttpServletRequest; 
    import javax.servlet.http.HttpServletResponse;
    import javax.servlet.http.HttpSession; 
    import java.io.IOException; 
    import java.io.Writer;
    public class AdminsessionFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig)throws ServletException {
    }
    @Override
    public void doFilter(ServletRequest request,ServletResponse response,FilterChain chain)
    throws IOException,ServletException
    
    {
    
    	HttpServletRequest httpServletRequest=(HttpServletRequest)request;
    	HttpServletResponse httpServletResponse=(HttpServletResponse)response;
    	
    	String url=httpServletRequest.getRequestURI(); 
    	if(url!=null && url.endsWith(".jsp")){
    		String contextPath=httpServletRequest.getContextPath();
    		httpServletResponse.sendRedirect(contextPath+"/index.html");
    		return;
    	}
    	chain.doFilter(httpServletRequest,httpServletResponse);
    }
    
    @Override
    public void destroy(){
    }
    
    
    }

    3.在部署文件web.xml中使用安全限制.配置如下:

    SP指令是指:用于设置JSP页面相关属性的一个语法命令,例如:设置页面编码字符集、导入其他包等等。JSP中提供了三个指令,分别是:page指令、include指令、taglib指令。其中page指令用于设置JSP页面属性,include指令用于引入其他的JSP文件,taglib指令用于引入标签库。这一小节内容介绍include指令的使用。

    1.1、include指令作用

    include指令作用:将指定的文件引入到当前JSP页面里面。include指令会将引入的文件内容嵌入到当前JSP页面中的对应位置。

    <%@ include file="文件的相对路径" %>

    案例代码:

    • 创建一个header.jsp文件。
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <html>
    <head>
        <title>这是HTML头部</title>
    </head>
    • 创建一个include.jsp文件。
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <%-- 引入头部文件 --%>
    <%@ include file="header.jsp" %>
    <body>
    
    <div style="background-color: cadetblue">
        这是正文内容区域
    </div>
    
    <%-- 引入底部文件 --%>
    <%@ include file="footer.html" %>
    </body>
    </html>
    • 创建一个footer.jsp文件。
    <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    <div style="background-color: antiquewhite;">
      这是footer底部内容区域
    </div>

    启动Tomcat容器,浏览器访问http://localhost:8080/servlet/include.jsp,结果如下:

    1.2、include指令的本质

    include指令的本质是什么呢???我们来查看下编译之后的Java源代码,找到上面include.jsp文件编译之后的源文件,如下所示:

    /*
     * Generated by the Jasper component of Apache Tomcat
     * Version: Apache Tomcat/8.5.98
     * Generated at: 2024-02-25 05:06:41 UTC
     * Note: The last modified time of this file was set to
     *       the last modified time of the source file after
     *       generation to assist with modification tracking.
     */
    package com.gitcode.servlet;
    
    import javax.servlet.*;
    import javax.servlet.http.*;
    import javax.servlet.jsp.*;
    
    public final class include_jsp extends org.apache.jasper.runtime.HttpJspBase
        implements org.apache.jasper.runtime.JspSourceDependent,
                     org.apache.jasper.runtime.JspSourceImports {
    
      private static final javax.servlet.jsp.JspFactory _jspxFactory=  javax.servlet.jsp.JspFactory.getDefaultFactory();
    
      private static java.util.Map<java.lang.String,java.lang.Long> _jspx_dependants;
    
      static {
        _jspx_dependants=new java.util.HashMap<java.lang.String,java.lang.Long>(2);
        _jspx_dependants.put("/footer.jsp", Long.valueOf(1708837593266L));
        _jspx_dependants.put("/header.jsp", Long.valueOf(1708837593271L));
      }
    
      private static final java.util.Set<java.lang.String> _jspx_imports_packages;
    
      private static final java.util.Set<java.lang.String> _jspx_imports_classes;
    
      static {
        _jspx_imports_packages=new java.util.HashSet<>();
        _jspx_imports_packages.add("javax.servlet");
        _jspx_imports_packages.add("javax.servlet.http");
        _jspx_imports_packages.add("javax.servlet.jsp");
        _jspx_imports_classes=null;
      }
    
      private volatile javax.el.ExpressionFactory _el_expressionfactory;
      private volatile org.apache.tomcat.InstanceManager _jsp_instancemanager;
    
      public java.util.Map<java.lang.String,java.lang.Long> getDependants() {
        return _jspx_dependants;
      }
    
      public java.util.Set<java.lang.String> getPackageImports() {
        return _jspx_imports_packages;
      }
    
      public java.util.Set<java.lang.String> getClassImports() {
        return _jspx_imports_classes;
      }
    
      public javax.el.ExpressionFactory _jsp_getExpressionFactory() {
        if (_el_expressionfactory==null) {
          synchronized (this) {
            if (_el_expressionfactory==null) {
              _el_expressionfactory=_jspxFactory.getJspApplicationContext(getServletConfig().getServletContext()).getExpressionFactory();
            }
          }
        }
        return _el_expressionfactory;
      }
    
      public org.apache.tomcat.InstanceManager _jsp_getInstanceManager() {
        if (_jsp_instancemanager==null) {
          synchronized (this) {
            if (_jsp_instancemanager==null) {
              _jsp_instancemanager=org.apache.jasper.runtime.InstanceManagerFactory.getInstanceManager(getServletConfig());
            }
          }
        }
        return _jsp_instancemanager;
      }
    
      public void _jspInit() {
      }
    
      public void _jspDestroy() {
      }
    
      public void _jspService(final javax.servlet.http.HttpServletRequest request, final javax.servlet.http.HttpServletResponse response)
          throws java.io.IOException, javax.servlet.ServletException {
    
        final java.lang.String _jspx_method=request.getMethod();
        if (!"GET".equals(_jspx_method) && !"POST".equals(_jspx_method) && !"HEAD".equals(_jspx_method) && !javax.servlet.DispatcherType.ERROR.equals(request.getDispatcherType())) {
          response.sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "JSP 只允许 GET、POST 或 HEAD。Jasper 还允许 OPTIONS");
          return;
        }
    
        final javax.servlet.jsp.PageContext pageContext;
        javax.servlet.http.HttpSession session=null;
        final javax.servlet.ServletContext application;
        final javax.servlet.ServletConfig config;
        javax.servlet.jsp.JspWriter out=null;
        final java.lang.Object page=this;
        javax.servlet.jsp.JspWriter _jspx_out=null;
        javax.servlet.jsp.PageContext _jspx_page_context=null;
    
    
        try {
          response.setContentType("text/html;charset=UTF-8");
          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');
          out.write('\r');
          out.write('\n');
          out.write("\r\n");
          out.write("<html>\r\n");
          out.write("<head>\r\n");
          out.write("    <title>这是HTML头部</title>\r\n");
          out.write("</head>");
          out.write("\r\n");
          out.write("<body>\r\n");
          out.write("\r\n");
          out.write("<div style=\"background-color: cadetblue\">\r\n");
          out.write("    这是正文内容区域\r\n");
          out.write("</div>\r\n");
          out.write("\r\n");
          out.write('\r');
          out.write('\n');
          out.write("\r\n");
          out.write("<div style=\"background-color: antiquewhite;\">\r\n");
          out.write("  这是footer底部内容区域\r\n");
          out.write("</div>");
          out.write("\r\n");
          out.write("</body>\r\n");
          out.write("</html>");
        } catch (java.lang.Throwable t) {
          if (!(t instanceof javax.servlet.jsp.SkipPageException)){
            out=_jspx_out;
            if (out !=null && out.getBufferSize() !=0)
              try {
                if (response.isCommitted()) {
                  out.flush();
                } else {
                  out.clearBuffer();
                }
              } catch (java.io.IOException e) {}
            if (_jspx_page_context !=null) _jspx_page_context.handlePageException(t);
            else throw new ServletException(t);
          }
        } finally {
          _jspxFactory.releasePageContext(_jspx_page_context);
        }
      }
    }

    通过上面源代码,可以看到,使用include指令引入的两个文件,最终都会将两个文件中的内容直接嵌入到当前include.jsp文件里面,如下所示:

    所以include指令的本质就是将引入文件中的内容,直接拼接到当前JSP页面的对应位置。这里也就会存在一个问题,引入的JSP文件中,不能存在和当前JSP页面相同的变量名称,因为变量名称相同会导致编译失败。另外,使用include指令引入其他的JSP文件时候,只会生成访问的那个JSP文件的源代码,被引入的JSP文件不会生成对应的源代码。

    以上,就是include指令的使用及其本质。

    今天就到这里,未完待续~~