javaee_javaeeapi - CSDN
javaee 订阅
Java EE 是 J2EE的一个新的名称,之所以改名,目的还是让大家清楚J2EE只是Java企业应用。在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出:我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。 展开全文
Java EE 是 J2EE的一个新的名称,之所以改名,目的还是让大家清楚J2EE只是Java企业应用。在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出:我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本。
信息
实    质
J2EE
性    质
Java企业应用
中文名
Java EE
核    心
EJB3.0
JavaEE简要介绍
Java EE是 J2EE的一个新的名称,之所以改名,目的还是让大家清楚J2EE只是Java企业应用.随着WEB和EJB容器概念诞生,使得软件应用业开始担心SUN的伙伴们是否还在Java平台上不断推出翻新的标准框架,致使软件应用业的业务核心组件架构无所适从,从一直以来是否需要EJB的讨论声中说明了这种彷徨。在2004年底中国软件技术大会Ioc微容器(也就是Jdon框架的实现原理)演讲中指出:我们需要一个跨J2SE/WEB/EJB的微容器,保护我们的业务核心组件(中间件),以延续它的生命力,而不是依赖J2SE/J2EE版本.此次J2EE改名为Java EE,实际也反映出业界这种共同心声。Java EE的核心是EJB3.0, 其提供了更兼便捷的企业级的应用框架。
收起全文
精华内容
参与话题
  • JavaEE详解-全程实战案例

    万人学习 2016-09-29 15:59:23
    肖老师这套课程:抛弃传统的知识点教学模式,采用全程案例教学模式,通过网上书城项目,把所有的JavaEE需要掌握的重要知识点都融入项目中,使学员可以掌握实用的知识,同时获得佳实践. 主要涉及内容有:多表查询、...
  • 从懵逼到再入门之--JavaEE完整体系架构

    万次阅读 多人点赞 2018-05-24 15:35:18
    理想的建筑师应该既是文学家又是数字家,他还应通晓历史,热衷于哲学研究,精通音乐,懂得医药知识,具有法学造诣,深谙天文学及天文计算。...本文是我自己学习JavaEE的体系架构的时候,根据各种资料学习涂涂画...

    转载:https://segmentfault.com/a/1190000007090110

    理想的建筑师应该既是文学家又是数字家,他还应通晓历史,热衷于哲学研究,精通音乐,懂得医药知识,具有法学造诣,深谙天文学及天文计算。 ——Vitruvius(古罗马建筑师) 约公元前25年

    软件架构同样需要方方面面的知识和积累。本文是我自己学习JavaEE的体系架构的时候,根据各种资料学习涂涂画画整理所得,有不对之处求轻喷,也请指出便于改正。

    JavaEE是一套使用Java进行企业级Web应用开发的大家一致遵循的工业标准。 JavaEE平台提供了一个基于组件的方法来加快设计、开发、装配及部署企业应用程序。 相较于Microsoft的.NET,Sun公司的Java*E和一系列标准、技术及协议更接近或更满足互联网在智能化Web服务方面对开放性、分布性和平台无关性的要求。

    JavaEE的13种核心技术规范:

    1、JDBC(Java Database)数据库连接

    JDBC是一组用于执行SQL的Java API ,为访问不同的数据库提供了一种统一的途径,几乎所有的关系型数据库厂商(DBMS)都提供了JDBC的服务或驱动。JDBC对数据库的访问也具有平台无关性。

    JDBC处理模型

    2、JNDI(Java Naming and Directory Interfaces)Java 的命名和目录接口

    JNDI是命名目录服务的抽象接口集合,为企业级应用提供了统一的标准化连接,使Java能够无缝地获取任何可目录化的企业信息。在JavaEE体系中,JNDI用来定位各种对象,包括EJB、数据库驱动、JDBC数据源及消息连接等。由于JNDI是独立于目录协议的,因此还可以用JNDI访问各种特定的目录服务,如LDAP(轻量目录访问协议)、NDS(服务器目录访问服务)。

    JNDI数据源

    3、EJB(Enterprise JavaBean)

    EJB组件:JavaBean是在编程环境(IDE)中能够被可视化处理的可重用组件,是实现分布式业务逻辑的 Java 组件。我们在开发的时候可以利用这些组件,像搭积木一样建立面向对象的分布式应用。 EJB容器:是EJB组件的运行环境,为部署EJB组件提供服务,包括事务、安全、远程客户端的网络发布、资源管理等。 EJB服务器:管理EJB容器的高端进程或应用程序,并提供对系统服务的访问。 调用EJB组件的应该称为EJB客户端,客户端可以运行在Web容器中。

    EJB

    4、RMI(Remote Method Invoke)远程方法调用

    RMI协议能够让在某个Java虚拟机上的对象,像调用本地对象一样调用另一个Java虚拟机中的对象上的方法。它使用了序列化方式在客户端和服务器端传送数据。RMI是一种被EJB使用的更底层的协议。(stub/skeleton层提供了客户程序和服务程序彼此交互的接口)

    RMI远程调用

    5、Java IDL(Interface Description Language)/CORBA(Common Object Broker Architecture)Java 接口定义语言/公用对象请求代理程序体系结构

    IDL是用来描述软件组件接口的一种计算机语言。IDL通过一种中立的方式来描述接口,使得在不同平台上运行的对象和用不同语言编写的程序可以相互通信交流。

    6、JSP(Java Server Pages)

    JSP页面由HTML代码和嵌入其中的Java代码所组成。服务器在页面被客户端所请求以后对这些Java代码进行处理,然后将生成的HTML页面返回给客户端的浏览器。 JSP可以使用Servlet提供的API,一般和JavaBean结合使用,从而将界面表现和业务逻辑分离。

    JSP

    7、Servlet

    Servlet是一种小型的Java程序,它扩展了Web服务器的功能。作为一种服务器端的应用,当被请求时开始执行。Servlet提供的功能大多与JSP类似,不过实现的方式不同。JSP通常是大多数HTML代码中嵌入少量的Java代码,而servlets全部由Java写成并且生成HTML。

    8、XML(Extensible Markup Language)可扩展白标记语言

    XML是一种用于标记电子文件使其具有结构性的标记语言。它被用来在不同的商务过程中共享数据。XML的发展和Java是相互独立的,但是它和Java有着相同的目标,即平台独立性。通过Java和XML的组合,可以得到一个完美的具有平台独立性的解决方案。

    9、JMS(Java Message Service)Java 消息服务

    JMS是Java的消息服务,JMS的客户端之间可以通过JMS服务进行异步的消息传输。JMS用于和面向消息的中间件相互通信的应用程序接口(API)。它既支持点对点的域,有支持发布/订阅(publish/subscribe)类型的域,并且提供对下列类型的支持:经认可的消息传递,事务型消息的传递,一致性消息和具有持久性的订阅者支持。 JMS消息系统带来的好处:1、提供消息灵活性;2、松散耦合;3、异步性。

    JMS点对点

    10、JTA(Java Transaction API)Java 事务 API

    在JavaEE应用中,事务是一个不可或缺的组件模型,它保证了用户操作ACID(即原子、一致、隔离、持久)属性。对于那些跨数据源(例如多个数据库,或者数据库与JMS)的大型应用,则必须使用全局事务JTA。应用系统可以由JTA定义的标准API访问各种事务监控,JTA为JavaEE平台提供了分布式事务服务,它隔离了事务与底层的资源,实现了透明的事务管理方式。

    JTA

    11、JTS(Java Transaction Service)Java 事务服务

    JTS是一个组件事务监视器。JTS是CORBA OTS事务监控的基本实现。JTS规定了事务管理器的实现方式。JTS事务管理器为应用服务器、资源管理器、独立的应用以及通信资源管理器提供了事务服务。

    12、JavaMail

    JavaMail是用于存取邮件服务器的API,它提供了一套邮件服务器的抽象类。不仅支持SMTP服务器,也支持IMAP服务器和POP服务器。

    13、JAF(JavaBean Activation Framework)

    JavaMail利用JAF来处理MIME编码的邮件附件。MIME的字节流可以被转换成Java对象,或者转换自Java对象。大多数应用都可以不需要直接使用JAF。

    JavaEE软件开发体系架构

    两层架构

    传统的客户服务器系统仅只简单地基于两层体系来构建,即客户端(前台)和企业信息系统(后台),没有任何中间件,业务逻辑层与表示层或数据层混在一起。这种两层架构无论从开发、部署、扩展、维护来说,综其只有一个特点——成本高。

    三层架构

    三层架构自上而下将系统分为表示层、逻辑层、持久层。 表示层由处理用户交互的客户端组件及其容器所组成; 业务逻辑层由解决业务问题的组件组成; 数据层由一个或多个数据库组成,并可包含存储过程。 这种三层架构,在处理客户端的请求时,使客户端不用进行复杂的数据库处理;透明地为客户端执行许多工作,如查询数据库、执行业务规则和连接现有的应用程序;并且能够帮助开发人员创建适用于企业的大型分布式应用程序。

    三层架构

    MVC

    在MVC模式中,应用程序被划分为模型层(Model)、视图层(View)、控制层(Controller)三部分。MVC模型就是把一个应用程序的开发按照业务逻辑、数据、视图进行分离分层并组织代码。MVC要求把应用的模型按一定的层次规则抽取出来,将业务逻辑聚集到一个部件里面,在改进和个性化定制界面及用户交互的同时,不需要重新编写业务逻辑。模型层负责封装应用的状态,并实现功能,视图层负责将内容呈现给用户,控制层负责控制视图层发送的请求以及程序的流程。 Servlet+JSP+JavaBean(MVC)这种模式比较适合开发复杂的web应用,在这种模式下,Servlet负责处理用户请求,JSP负责数据显示,JavaBean负责封装数据。 MVC

    基于JavaEE架构模式下的MVC

    在这种架构模式下,模型层(Model)定义了数据模型和业务逻辑。为了将数据访问与业务逻辑分离,降低代码之间的耦合,提高业务精度,模型层又具体划分为了DAO层和业务层,DAO即Data Access Object,其主要职能是将访问数据库的代码封装起来,让这些代码不会在其它层出现或者暴露出来给其它层;业务层是整个系统最核心也是最具有价值的一层,该层封装应用程序的业务逻辑,处理数据,关注客户需求,在业务处理过程中会访问原始数据或产生新数据,DAO层提供的DAO类能很好地帮助业务层完成数据处理,业务层本身侧重于对客户需求的理解和业务规则的适应,总体说来,DAO层不处理业务逻辑,只为业务层提供辅助,完成获取原始数据或持久层数据等操作。

    基于JavaEE架构模式下的MVC

    • JSP:JSP被用来产生Web的动态内容。这层把应用数据以网页的形式呈现给浏览器,然后数据按照在JSP中开发的预定的方式表示出来,这层也可以称之为布局层。
    • Servlet:JSP建立在Servlet之上,Servlet是J2EE的重要组成部分。Servlet负责处理用户请求,Java Web项目的所有配置都写在了web.xml配置文件里,当项目运行的时候,web.xml会将http请求映射给对应的Servlet类。
    • JavaBean:由一些具有私有属性的Java类组成,对外提供get和set方法。JavaBean负责数据,负责处理视图层和业务逻辑之间的通信。
    • Service:业务处理类,对数据进行一些预处理。
    • DAO:数据访问层,JDBC调用存储过程,从数据库(DataBase)那里获取到数据,再封装到Model实体类中去。

    需要文中的资料可以私我。

    展开全文
  • JavaEE 从入门到放弃(一):Java EE 是个什么东西

    万次阅读 多人点赞 2018-07-09 19:34:09
    从整体上认识 JavaEE,看看 JavaEE 的主要内容。

    为什么选择 Java

    想必有很多初学者会像我一样,不知选择什么语言入门。在尝试了 C、C++、C#、Python、PHP 后,我决定把 Java作 为第一门深入学习的编程语言。这个路着实有点长…

    不过放心,你可以大胆地选择 Java。如果说 C++ 是编程界的曹操,那 Java 就是司马懿,近三十年踏惊涛骇浪如履平地,熬死了无数对手。

    诞生之初,Java 饱受争议。而如今,那些受到攻击的弱点一个个被解决甚至反超对手。人们开始惊叹 Java 的生命力,长期以来,Java雄踞编程语言排行榜首位,拥有最多的受众、最大的市场、最活跃的社区。

    TIOBE 编程语言排行榜:https://www.tiobe.com/tiobe-index/

    就在我写这篇博客的今天(18.07.09),我看到了一则消息,JDK 11中将会引入新的GC(Garbage Collection,垃圾回收)算法 ZGC,能够处理 TB 级别的 HEAP GC,GC 停顿时间不超过10s,意味着,几乎所有的民用场合,都可以用Java来写了,而且可以随心所欲地造对象,不用像以前一样小心翼翼了。

    当然,每个时期都有冉冉升起的新星。现在 Python 如日中天,Go 野心勃勃,选择Java 的你,可以选择喝杯茶看它们闹腾了(逃…)

    什么是 JavaEE

    JavaEE 概念

    Java EE,Java 平台企业版(Java Platform Enterprise Edition),之前称为Java 2 Platform, Enterprise Edition (J2EE),2018年3月更名为 Jakarta EE(这个名称应该还没有得到群众认可)。狭义的 Java EE 是 Sun 公司为企业级应用推出的标准平台,用来开发B/S架构软件,可以说是一个框架,也可以说是一种规范。

    广义的 Java EE 包含各种框架,其中最重要的就是 Spring 全家桶。Spring 诞生之初是为了改进 Java EE 开发的体验,后来逐渐成为了 Java Web 开发的实际标准。后面的文章里,会对 Spring 进行进一步的说明。

    JavaEE 与 JavaSE 的区别与联系

    JavaEE 是在 JavaSE 的基础上构建的,是对 JavaSE 的扩展,增加了一些更加便捷的应用框架。

    除了 EE 和 SE,还有为移动端而生的 JavaME,但目前应用不算广泛。三者的关系可以用下图概括:

    JavaSE\EE\ME关系

    JavaEE主要技术

    JavaEE 号称有十三种核心技术。它们分别是:JDBCJNDIEJB、RMI、ServletJSP、XML、JMS、Java IDL、JTS、JTA、JavaMail和JAF。

    简单介绍下需要重点关注的技术。

    JDBC

    Java 数据库连接,(Java Database Connectivity,JDBC)是 Java 语言中用来规范客户端程序如何来访问数据库的应用程序接口,提供了诸如查询和更新数据库中数据的方法。

    JNDI

    Java 命名和目录接口(Java Naming and Directory Interface,JNDI),是 Java 的一个目录服务应用程序界面(API),它提供一个目录系统,并将服务名称与对象关联起来,从而使得开发人员在开发过程中可以使用名称来访问对象。

    EJB

    企业级 JavaBean(Enterprise JavaBean, EJB)是一个用来构筑企业级应用的服务器端可被管理组件。不过这个东西在 Spring 问世后基本凉凉了,知道是什么就行。

    Servlet

    Servlet(Server Applet),是用 Java 编写的服务器端程序。其主要功能在于交互式地浏览和修改数据,生成动态 Web 内容。

    狭义的 Servlet 是指 Java 语言实现的一个接口,广义的 Servlet 是指任何实现了这个 Servlet 接口的类,一般情况下,人们将 Servlet 理解为后者。

    JSP

    JSP(全称JavaServer Pages)是由 Sun 公司主导创建的一种动态网页技术标准。JSP 部署于网络服务器上,可以响应客户端发送的请求,并根据请求内容动态地生成 HTML、XML 或其他格式文档的 Web 网页,然后返回给请求者。

    JavaEE框架

    JavaEE 拥有广泛市场的原因之一就是可以使用多种框架来使开发变得简单。对于框架的选择多种多样,目前比较常见的框架组合SSHSSM。在后面的章节中会作详细介绍。另外Spring本身也提供了多种层次的框架供选择,可以到Spring官网了解详情。

    Spring: https://spring.io/

    SSH

    Structs + Spring + Hibernate

    SSM

    Spring +SpringMVC + MyBatis

    JavaEE 学习路径

    一般来讲,初学者应该遵循以下路径

    Servlet -> JSP -> Spring -> 组合框架

    Servlet 和 JSP 在日后的开发中虽然很少直接应用,但却是各种框架的基础,应该放在开始去了解。这两部分也并不难,相信经过了 JavaSE 的洗礼,只需要进行短期的学习,知道它们都是什么,就可以投入实践中了。

    至于上面提到的其它内容,在实践中遇到了再去了解也不妨,现在也只能在一些老旧的应用中看到这些东西了。JDBC 可以稍微重点关注一下,其它的知道有这么个词就差不多啦。

    推荐一个学习 Java 的良心网站,里面有 Java 全栈知识,在每个阶段都设置了练习内容,谁用谁知道——

    「How2J 的 Java 教程」


    这个系列的文章我会逐步更新,主要是希望帮助大家对 Java Web 开发建立一个大概的认识,感兴趣的小伙伴可以戳下面的连接——

    JavaEE 从入门到放弃(二):一文读懂 Servlet
    JavaEE 从入门到放弃(三):为什么要用 JSP?
    JavaEE 从入门到放弃(四):MVC 模式
    JavaEE 从入门到放弃(五):如何理解 Spring
    JavaEE 从入门到放弃(六):框架的选择
    (持续更新中)

    另外我用 Vue + Spring Boot 做了一个前后端分离的小项目,并做了一下实践教程,有兴趣的小伙伴可以戳以下链接——

    Vue + Spring Boot 项目实战

    在学习中遇到问题,或者想与我交流学习经验,可以给我发送邮件,地址是:evan_nightly@163.com

    有兴趣听我吹牛扯皮的同学可以关注我的公号,只讲故事,不谈技术。
    heihei

    展开全文
  • JavaEE框架

    千人学习 2018-12-19 18:46:50
    针对企业开发的主流框架进行讲解,注重理论和实践...使学生具备开发企业级项目的能力,同时针对框架新特性也有讲授,通过这些新功能实用性强、易用性高,可大幅降低 JavaEE 开发的难度,同时有效提升应用开发的优雅性。
  • javaEE

    千次阅读 2019-04-24 15:40:36
    Tomcat 1、程序架构 1-1、C/S架构(Client — Server) ​ 一种两层结构的系统,第一层在客户机上安装了客户机应用程序,第二层在服务器上安装服务器管理程序.在C/S模式的工作过程中,客户机程序发出请求,服务器程序...

    Tomcat

    1、程序架构

    1-1、C/S架构(Client — Server)

    ​ 一种两层结构的系统,第一层在客户机上安装了客户机应用程序,第二层在服务器上安装服务器管理程序.在C/S模式的工作过程中,客户机程序发出请求,服务器程序接收并且处理客户机程序提出的请求,然后返回结果 。

    C/S模式有以下特点:
    ​ 1、C/S模式将应用与服务分离,系统具有稳定性和灵活性
    ​ 2、C/S模式配备的是点对点的结构模式,适用于局域网,有可靠的安全性
    ​ 3、由于客户端实现与服务器端的直接连接,没有中间环节,因此响应速度快
    ​ 4、在C/S模式中,作为客户机的计算机都要安装客户机程序,一旦软件系统升级,每台客户机都要安装客户机程序,系统升级和维护较为复杂

    1-2、B/S架构(Browser — Server)

    ​ 浏览器/服务器模式,是一种从传统的两层C/S模式发展起来的新的网络结构模式,其本质是三层结构的C/S模式。在用户的计算机上安装浏览器软件,在服务器上存放数据并且安装服务应用程序,服务器有WWW服务器和文件服务器等。用户通过浏览器访问服务器,进行信息浏览、文件传输和电子邮件等服务。

    B/S模式有以下特点:
    ​ 1、系统开发、维护、升级方便
    ​ 每当服务器应用程序升级时,只要在服务器上升级服务应用程序即可,用户计算机上的浏览器软件不需要修改,系统开发和升级维护方便
    ​ 2、B/S模式具有很强的开放性
    ​ 在B/S模式下,用户通过通用的浏览器进行访问,系统开放性好
    ​ 3、B/S模式的结构易于扩展
    ​ 由于Web的平台无关性,B/S模式的结构可以任意扩展,可以从包含一台服务器和几个用户的小型系统扩展成为拥有成千上万个用户的大型系统
    ​ 4、用户使用方便
    ​ B/S模式的应用软件都是基于Web浏览器的,而Web浏览器的界面是类似的。对于无用户交换功能的页面。用户接触的界面都是一致的,用户使用方便

    2、web交互机制

    ​ 客户端根据用户输入的地址信息请求服务器,服务器在接收到用户的请求后进行处理,然后将处理结果响应给客户端,客户端将响应结果展示给用户。

    专业术语:
    ​ 请求:客户端根据用户地址信息将数据发送给服务器的过程
    ​ 响应:服务器将请求的处理结果发送给浏览器的过程

    问题:客户端也就是浏览器的版本是有很多的,服务器的版本也是有很多的,如何实现不同版本的浏览器和不同版本的服务器之间的数据交互呢?

    解决:规范浏览器和服务器的数据交互的格式。

    实现:HTTP 协议

    2-1、HTTP概念

    超文本传输协议(Hyper Text Transfer Protocol)

    作用:
    ​ 规范了浏览器和服务器的数据交互

    特点:

    ​ 简单快速:
    ​ 客户向服务器请求服务时,只需传送请求方法和路径。
    ​ 请求方法常用的有 GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。
    ​ 由于 HTTP 协议简单,使得 HTTP 服务器的程序规模小,因而通信速度很快

    ​ 灵活:
    ​ HTTP 允许传输任意类型的数据对象。正在传输的类型由Content-Type 加以标记。

    ​ 无连接:
    ​ 无连接的含义是限制每次连接只处理一个请求。服务器处理完请求,并收到客户的应答后,即断开连接。
    ​ 采用这种方式可以节省传输时间。

    ​ 无状态:
    ​ HTTP 协议是无状态协议。无状态是指协议对于事务处理没有记忆能力
    ​ 缺少状态意味着如果后续处理需要前面的信息,则它必须重传,这样可能导致每次连接传送的数据量增大。
    ​ 在服务器不需要先前信息时它的应答就较快。支持 B/S 及 C/S 模式。HTTP1.1 版本后支持可持续连接。

    2-2、HTTP交互

    交互流程:
    ​ 步骤一:
    ​ 客户端和服务器端建立连接
    ​ 步骤二:
    ​ 客户端发送请求数据到服务器端(HTTP 协议)
    ​ 步骤三:
    ​ 服务器端接收到请求后,进行处理,然后将
    ​ 处理结果响应客户端(HTTP 协议)
    ​ 步骤四:
    ​ 关闭客户端和服务器端的连接(HTTP1.1 后不会立即关闭)

    请求格式:
    ​ 请求头:请求方式、请求的地址和 HTTP 协议版本
    ​ 请求行:消息报头,一般用来说明客户端要使用的一些附加信息
    ​ 空行: 位于请求行和请求数据之间,空行是必须的。
    ​ 请求数据:非必须。

    请求方式:

    请求方式 解释
    get 请求页面信息,并返回实体主体
    head 跟get方式差不多,只是返回的响应中没有具体的内容,用于获取报头
    post 向指定的资源数据提交处理请求,数据包含在请求体中;post可能会导致新的资源产生,或者已有资源被修改
    put 从客户端向服务器传送的数据取代文档的内容
    delete 请求服务器删除指定的页面
    connect HTTP/1.1预留给能够将连接改为管道方式的代理服务器
    options 允许客服端查看服务器的性能
    trace 回显服务器收到的请求,用于测试或诊断

    getpost 请求方式的区别:
    ​ get 请求方式:
    ​ 请求数据会以?的形式隔开拼接在请求头中,不安全,没有请求实体部分。
    ​ HTTP 协议虽然没有规定请求数据的大小,但是浏览器对 URL 的长度是有限制的,
    ​ 所以 get 请求不能携带大量的数据。适合小数据请求
    ​ post 请求方式:
    ​ 请求数据在请求实体中进行发送,在 URL 中看不到具体的请求数据,安全。适合数据量大的数据

    响应:
    ​ 响应行(状态行):HTTP 版本、状态码、状态消息
    ​ 响应头:消息报头,客户端使用的附加信息
    ​ 空行:响应头和响应实体之间的,必须的。
    ​ 响应实体:正文,服务器返回给浏览器的
    ​ 响应状态码

    HTTP 状态码由三个十进制数字组成,第一个十进制数字定义了状态码
    的类型,后两个数字没有分类的作用。HTTP 状态码共分为 5 种类型:

    分类 描述
    1** 服务器收到请求,需要操作者继续进行操作
    2** 操作成功被接收并处理
    3** 重定向,需要进一步的操作完成请求
    4** 客户端错误,请求包含语法错误或请求无法完成
    5** 服务器错误,服务器在处理请求过程中发生了错误

    常见错误码:

    200 OK		//客户端请求成功
    400 Bad Request  	//客户端请求有语法错误,不能被服务器所理解
    401 Unauthorized  	//请求未经授权,这个状态代码必须和WWW-Authenticate 报头域一起使用
    403 Forbidden	//服务器收到请求,但是拒绝提供服务
    404 Not Found	//请求资源不存在,eg:输入了错误的 URL
    500 Internal Server Error	//服务器发生不可预期的错误
    503 Server Unavailable	//服务器当前不能处理客户端的请求,一段时间后可能恢复
    

    3、Tomcat服务器

    3-1、服务器

    ​ 所谓服务器其实就是代码编写的一个可以根据用户请求实时的调用执行对应的逻辑代码的一个容器。在普通用户看来就是一个安装程序。我们只需要将服务器在操作系统上进行安装,并将我们事先编写好的逻辑处理代码根据规则放到服务器的指定位置,启动服务器,那么服务器就自动的会根据接收到请求调用并执行对象的逻辑代码进行处理。

    3-2、目录

    \bin 存放启动和关闭 Tomcat 的可执行文件
    \conf 存放 Tomcat 的配置文件
    \lib 存放库文件
    \logs 存放日志文件
    \temp 存放临时文件
    \webapps 存放 web 应用
    \work 存放 JSP 转换后的 Servlet 
    

    Servlet

    1、Servlet简介

    1-1、概念

    ​ 狭义的 Servlet 是指 Java 语言实现的一个接口,广义的 Servlet 是指任何实现了这个 Servlet 接口的类,一般情况下,人们将 Servlet 理解为后者。Servlet 运行于支持 Java 的应用服务器中。从原理上讲,Servlet 可以响应任何类型的请求,但绝大多数情况下 Servlet 只用来扩展基于 HTTP 协议的 Web 服务器。

    1-2、特点

    ​ 运行在支持 java 的应用服务器上Servlet 的实现遵循了服务器能够识别的规则,也就是服务器会自动的根据请求调用对应的 servlet 进行请求处理,简单方便,可移植性强。

    1-3、使用

    ​ 1、 创建普通的 java 类并继承 HttpServlet
    ​ 2、 覆写 service 方法

    public class MyServlet extends HttpServlet{
        @Override
        protected void service(HttpServletRequest req,HttpServletResponse resp)
        	throws ServletException, IOException {
                resp.getWriter().write("this is my first servlet.");
                System.out.println("this is my first servlet.");
        }
    }
    

    ​ 3、 在 service 方法中书写逻辑代码即可
    ​ 4、 在 webRoot 下的 WEB-INF 文件夹下的 web.xml文件中配置 servlet

    <!--配置servlet类路径 -->
        <servlet>
            <servlet-name>my</servlet-name>
            <servlet-class>com.bjsxt.servlet.MyServlet</servlet-class>
        </servlet>
    <!--配置访问方式 -->
        <servlet-mapping>
            <servlet-name>my</servlet-name>
            <url-pattern>/my</url-pattern>
        </servlet-mapping>
    

    1-4、运行流程

    ​ 浏览器发送请求到服务器,服务器根据请求 URL 地址中的 URI 信息在 webapps 目录下找到对应的项目文件夹,然后在 web.xml 中检索对应的 servlet,找到后调用并执行Servlet。

    URL(服务器地址:端口号/虚拟项目名 /servlet 的别名)

    url:http://localhost:8080/project/my2
    

    URI(虚拟项目名 /servlet 的别名)

    project/my2
    

    1-5、servlet生命周期

    ​ 1、从第一次调用到服务器关闭。
    ​ 2、如果Servlet在web.xml中配置了load-on-startup,生命周期为从服务器启动到服务器关闭

    注意:
    ​ init() 方法是对Servlet进行初始化的一个方法,会在Servlet第一次加载进行存储时执行
    ​ destory() 方法是在servlet被销毁时执行,也就服务器关闭时。

    1-6、servlet交互方法

    ​ Service方法:
    ​ 可以处理get/post方式的请求,如果servlet中有Service方法,会优先调用service方法对请求进行处理。
    ​ doGet方法:
    处理get方式的请求
    ​ doPost方法:
    ​ 处理post方式的请求
    ​ 注意:
    ​ 如果在覆写的service方法中调用了父类的service方法(super.service(arg0, arg1)),
    ​ 则service方法处理完后,会再次根据请求方式响应的doGet和doPost方法执行。所以,一般情况下
    ​ 我们是不在覆写的service中调用父类的service方法的,避免出现405错误。

    1-7、Servlet常见错误

    ​ 404错误:资源未找到
    ​ 原因一:在请求地址中的servlet的别名书写错误。
    ​ 原因二:虚拟项目名称拼写错误
    ​ 500错误:内部服务器错误
    ​ 错误一:
    ​ java.lang.ClassNotFoundException: com.bjsxt.servlet.ServletMothod
    ​ 解决:
    ​ 在web.xml中校验servlet类的全限定路径是否拼写错误。
    ​ 错误二:
    ​ 因为service方法体的代码执行错误导致
    ​ 解决:
    ​ 根据错误提示对service方法体中的代码进行错误更改。
    ​ 405错误:请求方式不支持
    ​ 原因:
    ​ 请求方式和servlet中的方法不匹配所造成的。
    ​ 解决:
    ​ 尽量使用service方法进行请求处理,并且不要再service方法中调用父类的service。

    2、请求与响应

    2-1、Request

    ​ 服务器接收到浏览器的请求后,会创建一个 Request 对象,对象中存储了此次请求相关的请求数据。服务器在调用 Servlet 时会将创建的Request 对象作为实参传递给 Servlet 的方法,比如:service 方法。

    获取请求头数据
        req.getMethod();//获取请求方式
        req.getRequestURL();//获取请求URL信息
        req.getRequestURI();//获取请求URI信息
        req.getScheme();//获取协议
    获取请求行数据
        req.getHeader("键名");//返回指定的请求头信息
        req.getHeaderNames();//返回请求头的键名的枚举集合
    获取用户数据
        req.getParameter("键名");//返回指定的用户数据
        req.getParameterValues("键名");//返回同键不同值的请求数据(多选),返回的数组。
        req.getParameterNames()//返回所有用户请求数据的枚举集合
    注意:
    	如果要获取的请求数据不存在,不会报错,返回null。
    	request对象由tomcat服务器创建,并作为实参传递给处理请求的servlet的service方法。
    

    ​ 问题:使用请求转发后,不同的 Servlet 之间怎么进行数据的共享呢?或者说数据怎么从一个 servlet 流转给另外一个 Servlet 呢?
    ​ 解决:使用 request 对象的作用域

    ​ 使用:

    request.setAttribute(object name,Object value);
    request.getAttribute(Object obj)
    

    ​ 作用:解决了一次请求内的不同 Servlet 的数据(请求数据+其他数据)共享问题。

    ​ 作用域:基于请求转发,一次请求中的所有 Servlet 共享。

    ​ 特点:
    ​ 服务器创建,每次请求都会创建,生命周期一次请求

    ​ 注意:
    ​ 使用 Request 对象进行数据流转,数据只在一次请求内有效。

    2-2、Response

    ​ 服务器在调用指定的 Servlet 进行请求处理的时候,会给 Servlet 的方法传递两个实参 request 和 response。其中 request 中封存了请求相关的请求数据,而 response 则是用来进行响应的一个对象。

    设置响应头
        setHeader(String name,String value);//在响应头中添加响应信息,但是同键会覆盖
        addHeader(String name,String value);//在响应头中添加响应信息,但是不会覆盖。
    设置响应状态
    	sendError(int num,String msg);//自定义响应状态码。
    设置响应实体
    	resp.getWrite().write(String str);//响应具体的数据给浏览器
    设置响应编码格式:
    	resp.setContentType("text/html;charset=utf-8");
    
    service请求处理代码流程:
        设置响应编码格式 
        获取请求数据
        处理请求数据
        数据库操作(MVC思想)	
        响应处理结果
    
    

    2-3、乱码

    请求中文乱码解决:
    	1、使用String进行数据重新编码
    		uname=new String(uname.getBytes("iso8859-1"),"utf-8");
    	2、使用公共配置
    	get方式:
    		步骤一:req.setCharacterEncoding("utf-8");
    		步骤二:
    			在tomcat的目录下的conf目录中修改server.xml文件:
    			在Connector标签中增加属性 useBodyEncodingForURI="true"
    	post方式:
    		req.setCharacterEncoding("utf-8");
    响应中文乱码解决:
    	resp.setContentType("text/html;charset=utf-8");
    
    

    2-4、转发与重定向

    请求转发:
    ​ 作用: 实现多个servlet联动操作处理请求,这样避免代码冗余,让servlet的职责更加明确。

    使用:		req.getRequestDispatcher("要转发的地址").forward(req, resp);
    
    

    ​ 地址: 相对路径,直接书写servlet的别名即可。
    ​ 特点: 一次请求,浏览器地址栏信息不改变。
    ​ 注意:请求转发后直接return结束即可。
    reuqet作用域:
    ​ 解决了一次请求内的servlet的数据共享问题
    重定向:
    ​ 作用: 解决了表单重复提交的问题,以及当前servlet无法处理的请求的问题。

    使用:		resp.sendRedirect(String uri);			如:resp.sendRedirect("/login/main");
    
    

    ​ 特点: 两次请求,两个request对象。浏览器地址栏信息改变
    ​ 时机:
    ​ 如果请求中有表单数据,而数据又比较重要,不能重复提交,建议使用重定向。
    ​ 如果请求被Servlet接收后,无法进行处理,建议使用重定向定位到可以处理的资源。

    3、Cookie

    ​ Cookie 技术其实是浏览器端的数据存储技术,解决了不同请求需要使用相同的请求数据的问题。我们把请求需要共享的请求数据,存储在浏览器端,避免用户进行重复的书写请求数据。但是哪些数据需要使用 Cookie 技术存储起来是一个主观问题,需要在后台进行响应的时候来告诉浏览器,有些数据其他请求还会使用,需要存储起来。——(浏览器端的存储技术)

    3-1、Cookie的创建和存储

    ​ 临时存储:
    ​ 不设置 cookie 信息的存储时间,周期为一次会话,存储在浏览器内存中
    ​ 定时存储:
    ​ 设置存储时间,周期为时间设置,存储在用户电脑中。

    1、创建Cookie对象
    	Cookie c=new Cookie(String name, String value);
    2、设置cookie(可选)
        c.setMaxAge(int seconds);//设置有效期
        c.setPath(String uri)//设置有效路径
    3、响应Cookie信息给客户端
    	resp.addCookie(c);
    
    

    如:

    //使用Cookie进行浏览器端的数据存储
        //创建Cookie对象
            Cookie c=new Cookie("mouse", "thinkpad");
            Cookie c2=new Cookie("key", "bjsxt");
        //设置Cookie
            //设置Cookie的有效期
          		c2.setMaxAge(3*24*3600);
            //设置有效路径
            	c2.setPath("/cookie/gc");
        //响应Cookie信息
        	resp.addCookie(c);
        	resp.addCookie(c2);
    
    

    3-2、Cookie的获取

    1、获取Cookie信息数组
    	Cookie[] cks=req.getCookies();
    2、遍历数组获取Cookie信息
    	使用for循环遍历即可,示例:
        //获取Cookie信息
            Cookie[] cks=req.getCookies();
            if(cks!=null){
                for(Cookie c:cks){
                    String name=c.getName();
                    String value=c.getValue();
                    System.out.println(name+":"+value);
                }
            }
    
    

    注意:
    ​ 一个Cookie对象存储一条数据。多条数据,可以多创建几个Cookie对象进行存储。
    特点:
    ​ 浏览器端的数据存储技术。
    ​ 存储的数据声明在服务器端。
    ​ 临时存储:存储在浏览器的运行内存中,浏览器关闭即失效。
    ​ 定时存储:设置了Cookie的有效期,存储在客户端的硬盘中,在有效期内符合路径要求的请求都会附带该信息。
    ​ 默认cookie信息存储好之后,每次请求都会附带,除非设置有效路径

    3-3、Cookie信息校验

    ​ 判断请求中是否携带正确的Cookie信息
    ​ 如果有则校验Cookie信息是否正确
    ​ 如果校验正确则直接响应主页面给用户
    ​ 如果校验不正确则响应登录页面给用户
    ​ 没有则请求转发给登录页面

    //获取请求信息
    	//获取Cookie信息
    		Cookie[] cks=req.getCookies();
    	//处理请求信息
    		if(cks!=null){
    			String uid="";
    			//遍历Cookie信息
    			for(Cookie c:cks){
    				if("uid".equals(c.getName())){
    					uid=c.getValue();
    				}
    			}
    			//校验UID是否存在
    				if("".equals(uid)){
    					//请求转发
    						req.getRequestDispatcher("page").forward(req, resp);
    						return;
    				}else{
    					//校验UID用户信息
    						//获取业务层对象
    							LoginService ls=new LoginServiceImpl();
    							User u=ls.checkUidService(uid);
    							if(u!=null){
    								//将用户数据存储到session对象中
    								req.getSession().setAttribute("user",u);
    								//网页计数器自增
    								int nums=(int)this.getServletContext().getAttribute("nums");
    								nums+=1;
    								this.getServletContext().setAttribute("nums", nums);
    								//重定向
    								resp.sendRedirect("/login/main");
    								return;
    							}else{
    								//请求转发
    								req.getRequestDispatcher("page").forward(req, resp);
    								return;
    							}
    					}
    				
    			}else{
    				//响应处理结果
    					//请求转发
    					req.getRequestDispatcher("page").forward(req, resp);
    					return;
    			}
    
    

    4、Session

    ​ 原理:
    ​ 用户第一次访问服务器,服务器会创建一个session对象给此用户,并将该session对象的JSESSIONID使用Cookie技术存储到浏览器中,保证用户的其他请求能够获取到同一个session对象,也保证了不同请求能够获取到共享的数据。

    ​ 特点:
    ​ 存储在服务器端
    ​ 服务器进行创建
    ​ 依赖Cookie技术
    ​ 一次会话默认存储时间是30分钟

    ​ 作用:session解决了一个用户的不同请求的数据共享问题,只要在JSESSIONID不失效和session对象不失效的情况下。用户的任意请求在处理时都能获取到同一个session对象。

    ​ 作用域:
    ​ 一次会话
    ​ 在JSESSIONID和SESSION对象不失效的情况下为整个项目内。

    使用

    ​ 使用时机:一般用户在登陆web项目时会将用户的个人信息存储到Sesion中,供该用户的其他请求使用。

    创建session对象/获取session对象:
    	HttpSession hs=req.getSession();
    	
    常用的方法:
        getId();  //得到session的编号
        setAttribute(key,value); //将数据保存在session范围
        getAttribute(key); //从session范围取出数据,默认是Object,需要强制转换
        removeAttribute(key); //从session范围移除叫key的对象
        setMaxInactiveInterval(5); //设置session最大的有效时间,单位是秒
        getMaxInactiveInterval();//得到session最大的有效时间,单位是秒
        invalidate();//设session失效
        
    设置session的有效时间:
    	方法一: 单位是秒
        	session.setMaxInactiveInterval(5);
    	方法二:当前项目web.xml或tomcat/conf/web.xml中,单位是分钟
            <session-config>
               <session-timeout>1</session-timeout>
            </session-config>
            
    session失效处理:
    	将用户请求中的JSESSIONID和后台获取到的SESSION对象的JSESSIONID进行比对,如果一致
    	则session没有失效,如果不一致则证明session失效了。重定向到登录页面,让用户重新登录。
    
    

    4-5、注意

    ​ a1.session默认有效时间是30分钟,可以通过setMaxInactiveInterval(5),设有效时间在指定的时间内session对象没有被使用则销毁,如果使用了则重新计时。
    ​ a2.session对象与浏览器对应,当前浏览器有一个网页没有关闭,session就是同一个对象,如果当前浏览器所有的 网页全部关闭,则重新创建一个新的session,JSESSIONID存储在了Cookie的临时存储空间中,浏览器关闭即失效。
    ​ a3.session实现同一个用户,多个页面数据的共享(前提是同一个浏览器)
    ​ a4.当超时的时间必须是整数,当设为0或负值表示session永远不失效
    ​ a5.只要不关闭浏览器,并且 session 不失效的情况下,同一个用户的任意请求在项目的任意Servlet中获取到的都是同一个session对象。

    ​ a6.存储的动作和取出的动作发生在不同的请求中,但是存储要先于取出执行。

    ​ include指令:实现页面的重用

    <%@include file="includePage.jsp" %>包含子页面到主页面中来
    相当于<iframe src="includePage.jsp"/>
    
    

    5、ServletContext

    ​ 问题:
    不同的用户使用相同的数据
    解决:
    ServletContext对象
    特点:
    服务器创建
    用户共享
    作用域:
    整个项目内
    生命周期:
    服务器启动到服务器关闭

    使用

    ​ 获取ServletContext对象

    //第一种方式:
    	ServletContext sc=this.getServletContext();
    //第二种方式:
    	ServletContext sc2=this.getServletConfig().getServletContext();
    //第三种方式:
    	ServletContext sc3=req.getSession().getServletContext();
    
    

    ​ 使用ServletContext对象完成数据共享

    sc.setAttribute(String name, Object value);//数据存储
    sc.getAttribute("str") //数据获取,返回的是Object类型
    
    
    注意:
    	不同的用户可以给ServletContext对象进行数据的存取。
    	获取的数据不存在返回null。
    获取项目中web.xml文件中的全局配置数据
    
    sc.getInitParameter(String name); 根据键的名字返回web.xml中配置的全局数据的值,返回String类型。
     								 如果数据不存在返回null。
    sc.getInitParameterNames();返回键名的枚举
    配置方式
    	一组<context-param>标签只能存储一组键值对数据,多组可以声明多个进行存储。<context-param>
        <param-name>name</param-name>
        	<param-value>zhangsan</param-value>
        </context-param>
    
    

    作用:将静态数据和代码进行解耦。
    获取项目webroot下的资源的绝对路径。获取的路径为项目根目录,path参数为项目根目录中的路径

    String path=sc.getRealPath(String path);
    
    

    获取webroot下的资源的流对象

    InputStream is = sc.getResourceAsStream(String path);
    
    

    注意:此种方式只能获取项目根目录下的资源流对象,class文件的流对象需要使用类加载器获取。path参数为项目根目录中的路径

    JSP

    1、JSP概述

    ​ JSP全名为Java Server Pages,中文名叫java服务器页面,其根本是一个简化的Servlet设计,它 是由Sun Microsystems公司倡导、许多公司参与一起建立的一种动态网页技术标准。JSP技术有点类似ASP技术,它是在传统的网页HTML(标准通用标记语言的子集)文件(.htm,.html)中插入Java程序段(Scriptlet)和JSP标记(tag),从而形成JSP文件,后缀名为(*.jsp)。 用JSP开发的Web应用是跨平台的,既能在Linux下运行,也能在其他操作系统上运行。

    常见的动态网页技术:JSP,ASP,PHP

    jsp的应用服务器有:tomcat,jboss ,weblogic websphere等

    1-1、特点

    ​ 本质上还是 Servlet
    ​ 跨平台,一次编写处处运行
    ​ 组件跨平台
    ​ 健壮性和安全性

    静态网页与动态网页的区别
    ​ 静态网页只能完成网站的基本结构,不能与用户交互,不能实时根据数据库中的记录更新;
    ​ 动态的网页技术可以与用户交互,能实时更新的

    1-2、URL

    http:// localhost : 8080/   news/index.jsp
      协议   主机地址    端口号  项目地址
    
    

    1-3、执行过程

    	翻译阶段----------->编译阶段--->运行阶段
    .jsp--->.java(servlet)--->.class------>.html
    
    

    2、jsp页面的组成

    a1.指令部分:page指令,include指令,taglib指令
    a2.html的模板元素(html的标签,css样式,js脚本)
    a3.小脚本 <% 纯java代码 %>
    a4.表达式 <%=表达式 %>表示在网页上输出,相当于java中的System.out.print()或html中的document.write();
    a5.声明 <%! 声明全部变量和方法%> 已淘汰了
    a6.注释部分
    ​ b1.html的注释也叫显示注释,服务器会运行这种注释
    ​ b2.jsp的注释,用来注释jsp的元素如小脚本 ,也叫隐式注释 <%-- jsp的注释,服务器不会运行 --%>
    ​ b3.java代码的注释 //单行或多行注释

    2-1、Jsp的page指令

    ​ <%@page 属性名=“属性值” 属性名=“属性值”…%>
    ​ language:声明jsp要被转译的语言。
    ​ import:声明转译的java文件要导入的包,不同的包使用逗号隔开。
    ​ pageEncoding:设置jsp文件的数据编码格式。
    ​ contentType=“text/html; charset=utf-8” :设置jsp数据响应给浏览器时,浏览器的解析和编码格式。
    ​ session:设置转译的servlet中是否开启session支持,默认开启,true表示开启。false表示关闭。
    ​ errorPage:设置jsp运行错误跳转的页面.
    ​ extends:设置jsp转译的java文件要继承的父类(包名+类名)。

    ​ 作用:配置jsp文件的转译相关的参数。

    2-2、局部代码块

    ​ 特点:
    ​ 局部代码块中声明的java代码会被原样转译到jsp对应的servlet文件的_JspService方法中
    ​ 代码块中声明的变量都是局部变量。
    ​ 使用:<% java代码 %>
    ​ 缺点:使用局部代码块在jsp中进行逻辑判断,书写麻烦,阅读困难。
    ​ 开发:servlet进行请求逻辑处理,使用jsp进行页面展现。

    2-3、全局代码块

    ​ 特点:
    ​ 声明的java代码作为全局代码转译到对应的servlet类中。
    ​ 使用:
    ​ <%! 全局代码 %>
    ​ 注意:
    ​ 全局代码块声明的代码,需要使用局部代码块调用。

    2-4、脚本段

    ​ 特点:帮助我们快速的获取变量或者方法的返回值作为数据响应给浏览器。
    ​ 使用:<%=变量名或者方法%>
    ​ 注意:不要在变量名或者方法后使用分号。
    ​ 位置:除jsp语法要求以外的任意位置。

    3、使用

    3-1、静态引入

    <%@include file="要引入的jsp文件的相对路径" %>
    
    

    ​ 特点:会将引入的jsp文件和当前jsp文件转译成一个java(Servlet)文件使用。在网页中显示合并后的显示效果。

    ​ 注意:静态引入的jsp文件不会单独转译成java(Servlet)文件。当前文件和静态引入的jsp文件中不能够使用java代码块声明同名变量。

    3-2、动态引入

    <jsp:include page="要引入的jsp文件的相对路径"></jsp:include>
    
    

    ​ 特点:会将引入的jsp文件单独转译,在当前文件转译好的java文件中调用引入的jsp文件的转译文件。在网页中显示合并后的显示效果。

    ​ 注意:动态引入允许文件中声明同名变量。

    3-3、jsp的转发标签forward

    ​ 优点:降低jsp代码的冗余,便于维护升级。 ​

    <jsp:forward page="要转发的jsp文件的相对路径"></jsp:forward>
    
    

    ​ 特点:一次请求,地址栏信息不改变。

    ​ 注意:在转发标签的两个标签中间除了写<jsp:param name=“str” value=“aaa” />子标签不会报错,其他任意字符都会报错。

    <jsp:forward page="要转发的jsp文件的相对路径">
        <jsp:param name="str" value="aaa" />
                name属性为附带的数据的键名
                value为附带的数据内容
    </jsp:forward>
    
    

    ​ 注意:会将数据以?的形式拼接在转发路径的后面。

    3-4、JSP路径

    相对路径
    ​ 问题一:资源的位置不可随意更改。
    ​ 问题二:需要使用 …/ 进行文件夹的跳出。使用比较麻烦。
    绝对路径
    ​ /虚拟项目名/项目资源路径

    <a href="/jsp/jspPro.jsp">jspPro.jsp</a>
    <a href="/jsp/a/a.jsp">a.jsp</a>
    		注意:在jsp中资源的第一个/表示的是服务器根目录,相当于:localhost:8080
    使用jsp中自带的全局路径声明:
    <%
    	String path = request.getContextPath();
    	String basePath = 	request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
    %>
    			<base href="<%=basePath%>">
    作用:给资源前面添加项目路径:http://127.0.0.1:8080/虚拟项目名/	
    
    

    4、内置对象

    ​ jsp文件在转译成其对应的Servlet文件的时候自动生成的并声明的对象。我们在jsp页面中直接使用即可。

    ​ 注意:内置对象在jsp页面中使用,使用局部代码块或者脚本段语句来使用。不能够在全局代码块中使用。

    4-1、九大内置对象

    pageContext:页面上下文对象,封存了其他内置对象。封存了当前jsp的运行信息。
        注意:每个Jsp文件单独拥有一个pageContext对象。
        作用域:当前页面。
    request:封存当前请求数据的对象。由tomcat服务器创建。一次请求
    session:此对象用来存储用户的不同请求的共享数据的。一次会话
    application:ServletContext对象,一个项目只有一个。存储用户共享数据的对象,以及完成其他操作。
    response:响应对象,用来响应请求处理结果给浏览器的对象。设置响应头,重定向。
    out:响应对象,Jsp内部使用。带有缓冲区的响应对象,效率高于response对象。
    page:代表当前Jsp的对象。相当于java中的this。
    exception:异常对象。存储了当前运行的异常信息。
        注意:使用此对象需要在page指定中使用属性isErrorPage="true"开启。
    config:也就是ServletConfig,主要是用来获取web.xml中的配置数据,完成一些初始化数据的读取。
    
    

    4-2、四个作用域对象

    pageContext:当前页面.解决了在当前页面内的数据共享问题。获取其他内置对象。
    request:一次请求。一次请求的servlet的数据共享。通过请求转发,将数据流转给下一个servlet。
    session:一次会话.一个用户的不同请求的数据共享。将数据从一次请求流转给其他请求。
    application:项目内.不同用户的数据共享问题。将数据从一个用户流转给其他用户。
    
    作用:数据流转
    	
    a1. page范围:指的是将数据保存在当前页面中
        pageContext.setAttribute(key,value); //保存数据
        pageContext.getAttribute(key); //取数据
        pageContext.removeAttribute(key); //根据key移除数据
    
    a2. request范围
        request.setAttribute(key,value); //保存数据
        request.getAttribute(key); //取数据
        request.removeAttribute(key); //根据key移除数据    
    
    a3. session范围
        session.setAttribute(key,value); //保存数据
        session.getAttribute(key); //取数据
        session.removeAttribute(key); //根据key移除数据  
    a4. application范围
        application.setAttribute(key,value); //保存数据
        application.getAttribute(key); //取数据
        application.removeAttribute(key); //根据key移除数据 
    
    使用频率由高到低:request > session > application > pageContext
    
    

    JavaBean

    1、JavaBean

    1-1、JavaBean介绍

    其实就是一个普通的Java类,遵循以下规则成为JavaBean

    ​ 1、必须要有无参构造方法
    ​ 2、类的属性私有化(外部不能直接访问属性)private
    ​ 3、对外提供共有的getter和setter方法(通过方法操作属性)

    使用场景

    ​ 1、项目的实体类符合JavaBean
    ​ 2、EL表达式,访问对象的属性${student.name} 原理调用getName()方法
    ​ 3、自定义标签处理,给属性赋值 setName(String name)

    作用

    ​ 用于封装业务的数据

    1-2、JavaBean的属性

    ​ a1、JavaBean的属性可以是任意类型,并且一个JavaBean可以有多个属性。
    ​ a2、每个属性通常都需要具有相应的setter、 getter方法,setter方法称为属性修改器,getter方法称为属性访问器。
    ​ a3、属性修改器必须以小写的set前缀开始,后跟属性名,且属性名的第一个字母要改为大写。
    ​ 例如,name属性的修改器名称为setName,password属性的修改器名称为setPassword。
    ​ a4、属性访问器通常以小写的get前缀开始,后跟属性名,且属性名的第一个字母也要改为大写。
    ​ 例如,name属性的访问器名称为getName,password属性的访问器名称为getPassword。
    ​ a5、一个JavaBean的某个属性也可以只有set方法或get方法,这样的属性通常也称之为只写、只读属性。

    ​ 注意:isText() 是获取boolean 类型的值 同样是符合JavaBean

    2、JSP、JavaBean(了解)

    2-1、<jsp:useBean>标签

    ​ <jsp:useBean>标签用于在指定的域范围内查找指定名称的JavaBean对象,如果存在则直接返回该JavaBean对象的引用,如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。

      <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
      <%--
      在jsp中使用jsp:useBean标签来实例化一个Java类的对象
      <jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>
          ┝<jsp:useBean>:表示在JSP中要使用JavaBean。
          ┝id:表示生成的实例化对象,凡是在标签中看见了id,则肯定表示一个实例对象。
          ┝class:此对象对应的包.类名称
          ┝scope:此javaBean的保存范围,四种范围:page、request、session、application
      --%>
     -------------------------------------------------------------------------------------------------- 
     <jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>	//创建bean对象
     --------------------------------------------------------------------------------------------------
     <%
         //person对象在上面已经使用jsp:useBean标签实例化了,因此在这里可以直接使用person对象
         //使用setXxx方法为对象的属性赋值
         //为person对象的name属性赋值
         person.setName("孤傲苍狼");
         //为person对象的Sex属性赋值
         person.setSex("男");
         //为person对象的Age属性赋值
         person.setAge(24);
         //为person对象的married属性赋值
         person.setMarried(false);
     %>
     --------------------------------------------------------------------------------------------------
     <!DOCTYPE HTML>
     <html>
         <head>
         	<title>jsp:useBean标签使用范例</title>
         </head>
        <body>
            <%--使用getXxx()方法获取对象的属性值 --%>
            <h2>姓名:<%=person.getName()%></h2>
            <h2>性别:<%=person.getSex()%></h2>
            <h2>年龄:<%=person.getAge()%></h2>
            <h2>已婚:<%=person.isMarried()%></h2>
        </body>
    </html>
    
    

    <jsp:useBean>标签的执行原理:

    ​ 首先在指定的域范围内查找指定名称的JavaBean对象,如果存在则直接返回该JavaBean对象的引用,如果不存在则实例化一个新的JavaBean对象并将它以指定的名称存储到指定的域范围中。

    //编译后的Java代码
    gacl.javabean.study.Person person = null;
           synchronized (_jspx_page_context) {
             person = (gacl.javabean.study.Person) _jspx_page_context.getAttribute("person", PageContext.PAGE_SCOPE);
             if (person == null){
               person = new gacl.javabean.study.Person();
               _jspx_page_context.setAttribute("person", person, PageContext.PAGE_SCOPE);
             }
           }
    
    

    2-2、<jsp:setProperty>标签

    ​ <jsp:setProperty>标签用于设置和访问JavaBean对象的属性。

    语法:

    语法格式一:	
    	<jsp:setProperty name="beanName" property="propertyName" value="string字符串"/>
    语法格式二:
    	<jsp:setProperty name="beanName" property="propertyName" value="<%= expression %>" />
    语法格式三:
    	<jsp:setProperty name="beanName" property="propertyName" param="parameterName"/>
    语法格式四:
    	<jsp:setProperty name="beanName" property= "\*" />
    	
    name:用于指定JavaBean对象的名称。 
    property:用于指定JavaBean实例对象的属性名。
    value:用于指定JavaBean对象的某个属性的值,value的值可以是字符串,也可以是表达式。为字符串时,该值会自动转化为JavaBean属性相应的类型,如果value的值是一个表达式,那么该表达式的计算结果必须与所要设置的JavaBean属性的类型一致。   
    param:用于将JavaBean实例对象的某个属性值设置为一个请求参数值,该属性值同样会自动转换成要设置的JavaBean属性的类型。
    
    注意:
        jsp:setProperty在设置对象的属性值时会自动把【字符串】转换成8种基本数据类型
        但是jsp:setProperty对于复合数据类型无法自动转换
        birthday属性是一个Date类型,这个属于复合数据类型,因此无法将字符串自动转换成Date 
       		<jsp:setProperty property="birthday" name="person" value="1988-05-07"/>--会报错
    
    

    使用:

    <jsp:useBean id="person" class="gacl.javabean.study.Person" scope="page"/>	//创建bean实例
    ---------------------------------------------------------------------------------------------------
    1、jsp:setProperty标签设置person对象的属性值:
    	<jsp:setProperty property="name" name="person" value="白虎神皇"/>
    	<jsp:setProperty property="sex" name="person" value="男"/>
    	<jsp:setProperty property="age" name="person" value="24"/>
    	<jsp:setProperty property="married" name="person" value="false"/>
    	<jsp:setProperty property="birthday" name="person" value="<%=new Date()%>"/>
    
     2、jsp:setProperty标签可以使用请求参数为bean的属性赋值:
     	<jsp:setProperty property="name" name="person" param="param_name"/>
    	param="param_name"用于接收参数名为param_name的参数值,然后将接收到的值赋给name属性
    
    3、jsp:setProperty标签用所有的请求参数为bean的属性赋值
    	<jsp:setProperty property="*" name="person"/>
    	property="*"代表bean的所有属性
    
    

    2-3、<jsp:getProperty>标签

    ​ <jsp:getProperty>标签用于读取JavaBean对象的属性,也就是调用JavaBean对象的getter方法,然后将读取的属性值转换成字符串后插入进输出的响应正文中。

    语法:

    <jsp:getProperty name="beanInstanceName" property="PropertyName" />
        name属性用于指定JavaBean实例对象的名称,其值应与<jsp:useBean>标签的id属性值相同。
        property属性用于指定JavaBean实例对象的属性名。
        如果一个JavaBean实例对象的某个属性的值为null,那么,使用<jsp:getProperty>标签输出该属性的结果将是一个内容为“null”的字符串。
    
    

    使用:

    <html>
        <head>
        	<title>jsp:getProperty标签使用范例</title>
        </head>
        <body>
            <%--使用jsp:getProperty标签获取对象的属性值 --%>
            <h2>姓名:<jsp:getProperty property="name" name="person"/></h2>
            <h2>性别:<jsp:getProperty property="sex" name="person"/></h2>
            <h2>年龄:<jsp:getProperty property="age" name="person"/></h2>
            <h2>已婚:<jsp:getProperty property="married" name="person"/></h2>
            <h2>出生日期:<jsp:getProperty property="birthday" name="person"/></h2>
        </body>
    </html>
    
    

    EL、JSTL

    1、EL表达式

    1-1、传统方式

    <b><%=request.getParameter("uname")%></b><br />
    <b><%=request.getAttribute("str") %></b><br />
    <b><%=((User)request.getAttribute("user")).getAddr().getTown() %></b><br />
    <b><%=((ArrayList)request.getAttribute("list")).get(2)%></b><br />
    <b><%=((User)(((ArrayList)request.getAttribute("list2")).get(0))).getAddr().getPre() %></b><br />
    <b><%=((HashMap)request.getAttribute("map")).get("c") %></b><br />
    <b><%=((User)(((HashMap)request.getAttribute("map2")).get("a1"))).getAddr().getCity() %></b><br />
    
    

    ​ 缺点:需要导包,需要强转,获取数据代码过于麻烦

    1-2、EL表达式

    ​ 语法:${表达式}

    ​ 作用:获取作用域对象中的数据。

    ​ 注意:获取的是pageContext、request、session、application四个对象中的数据,其他数据一概不理会。找到了则获取返回,找不到则什么都不做,也不报错。

    1、获取请求数据(request对象)
        {param.键名}		返回值
        {paramvalues.键名}		返回的是数组
    2、通过setAttribute方法存储到作用域对象中的数据
    	{键名} 返回键名所对应的值。
    	普通字符串则直接返回
    3、获取对象中的数据:
    	普通对象:{键名.属性名.属性名....}
    	集合对象:list集合--->{键名[角标]}
    			map集合--->{键名.map集合存储的键名}	
    
    

    ​ 如:

    使用EL表达式获取作用域对象数据
        <b>${param.uname}</b><br />
        <b>${paramValues.fav[0]}</b><br />
        <b>${str}</b><br />
        <b>${user}</b><br />
        <b>${list[2]}</b><br />
        <b>${list2[0].addr.pre}</b><br />
        <b>${map.c}</b><br />
        <b>${map2.a1.addr.city}</b><br />
    
    

    1-3、作用域

    ​ 作用域查找顺序:
    ​ pageConext—request—session—application
    ​ (每次查找都是从小到大进行查找,找到了则获取,不再继续找)
    ​ 指定作用域查找:
    ​ ${pageScope.键名}
    ​ ${requestScope.键名}
    ​ ${sessionScope.键名}
    ​ ${applicationScope.键名}

    pageContext.setAttribute("hello","hello pageContext");
    request.setAttribute("hello","hello request");
    session.setAttribute("hello","hello session");
    application.setAttribute("hello","hello application");
    
    ${pageScope.hello}---${requestScope.hello}--${sessionScope.hello}--${applicationScope.hello}
    
    

    1-4、逻辑运算

    ​ ${逻辑表达式}:&& || !

    ​ ${算术表达式}:+,-,*,/

    ​ ${关系表达式}:>,<,>=,==,!=,%
    ​ 特殊:三目运算

    ​ 注意: + 表示加法运算,不表示字符链接。使用EL表达式进行字符链接会报错。EL表达式的逻辑运算

    ${1+2}--${1*2}--${4/2}--${4-2}--${4%3}--${4==4}--${4>2}--${sex==1?'男':'女'}--${1+'2'}
    
    

    1-5、空值判断

    ​ ${empty 键名}
    ​ 作用:判断键名对象的值是否存有数据。

    ${empty s}--${empty s1}--${empty s2}---${empty s3}
    
    

    1-6、获取请求头和cookie

    ​ 获取请求头数据

    ${header}-->返回所有的请求头数据
    ${header["键名"]}--->返回指定的键名的请求头数据
    ${hedaerValues["键名"]}--->返回指定的键名(同键不同值)的值的数组。
    
    

    ​ 获取Cookie数据

    ${cookie}--->返回存储了所有的cookie对象的map集合
    ${cookie.键名}---->返回指定的cookie对象
    ${cookie.键名.name}--->返回指定的cookie对象存储的数据的键名。
    ${cookie.键名.value}--->返回指定的cookie对象存储的数据的值。		
    
    

    ​ 例:

    ${header}--${headerValues["accept-language"][0]} <br /><br /><br />
    ${cookie}--${cookie.JSESSIONID}---${cookie.JSESSIONID.name}--${cookie.JSESSIONID.value}
    
    

    1-7、隐含对象

    隐含对象 描述
    pageScope page 作用域
    requestScope request 作用域
    sessionScope session 作用域
    applicationScope application 作用域
    param Request 对象的参数,字符串
    paramValues Request对象的参数,字符串集合
    header HTTP 信息头,字符串
    headerValues HTTP 信息头,字符串集合
    initParam 上下文初始化参数
    cookie Cookie值
    pageContext 当前页面的pageContext

    2、JSTL

    作用:提高在jsp中的逻辑代码的编写效率,使用标签。

    2-1、核心标签库(core)

    <%@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>		<!--导入core核心jar包-->
    
    

    2-1-1、基本标签

    <c:out value="数据" default="默认值"></c:out>
    	作用:将数据输出给客户端。
    		数据可以为常量值也可以是EL表达式。
    <c:set var="hello" value="hello pageContext" scope="page"></c:set>
    	作用:存储数据到作用域对象中
    		var:表示存储的键名
    		value:表示存储的数据
    		scope:表示要存储的作用域对象 page request session application
    <c:remove var="hello" scope="page"/>
    	作用:删除作用域中的指定键的数据。
    		var:表示要删除的键的名字
    		scope:表示要删除的作用域(可选)
    		
    注意:如果在不指定作用域的情况使用该标签删除数据,会将四个作用域对象中的符合要求的数据全部删除。
    
    
    <h3>基本标签学习</h3>
    <c:out value="哈哈"></c:out>---哈哈--${str2}<br />
    <c:out value="${str2}" default="嘿嘿"></c:out><br />
    <c:set var="hello" value="hello pageContext" scope="page"></c:set><br />
    <c:set var="hello" value="hello request" scope="request"></c:set><br />
    <c:set var="hello" value="hello session" scope="session"></c:set><br />
    <c:set var="hello" value="hello application" scope="application"></c:set><br />
    <%-- <c:out value="${applicationScope.hello}"></c:out> --%>
    <c:remove var="hello" scope="page"/><br />
    <c:out value="${hello}"></c:out>
    <hr />			
    
    

    2-1-2、逻辑标签

    <c:if>

    <c:if test="${表达式}">
    	前端代码
    </c:if>
    
    作用:进行逻辑判断,相当于java代码的单分支判断。
    注意:逻辑判断标签需要依赖于EL的逻辑运算,也就是表达式中涉及到的数据必须从作用域中获取。
    ---------------------------------------------------------------------------------------------------
    <c:set var="a" value="4"></c:set>
    <c:if test="${a>3}">
    	<b>今天的天气有点热哦</b>
    </c:if>
    
    

    <c:choose>

    <c:choose>
        <c:when test="">执行内容</c:when>
        <c:when test="">执行内容</c:when>
        ...
    	<c:otherwise>执行内容</c:otherwise>
    </c:choose>
    
    作用:用来进行多条件的逻辑判断,类似java中的多分支语句
    注意:条件成立只会执行一次,都不成立则执行otherwise
    ---------------------------------------------------------------------------------------------------
    <c:set var="score" value="68"></c:set>
    <c:choose>
    	<c:when test="${score>=90}">
    		<i>奖励吃鸡装配一套</i>
    	</c:when>
    	<c:when test="${score<90&&score>=80}">
    		<i>奖励空投箱</i>
    	</c:when>
    	<c:when test="${score<80&&score>=70}">
    		<i>无奖励无惩罚</i>
    	</c:when>
    	<c:otherwise>
    		<i>男女混合双打</i>
    	</c:otherwise>
    </c:choose>
    
    

    <c:foreach>

    <c:forEach begin="1" end="4" step="2">
        循环体
    </c:forEach>
    
        begin:声明循环开始位置
        end:声明循环结束位置
        step:设置步长
        varStatus:声明变量记录每次循环的数据(角标,次数,是否是第一次循环,是否是最后一次循环)
        items:声明要遍历的对象。结合EL表达式获取对象
        var:声明变量记录每次循环的结果。存储在作用域中,需要使用EL表达式获取。
        
    作用:循环内容进行处理    
    注意:数据存储在作用域中,需要使用EL表达式获取。
    	例如:${vs.index}--${vs.count}--${vs.first}--${vs.last}
    ---------------------------------------------------------------------------------------------------
    <!--1、常量循环  -->
        <c:forEach begin="0" end="4" step="1" varStatus="vs">
            1111---${vs.index}--${vs.count}--${vs.first}--${vs.last}<br />
        </c:forEach>
        
    <!--2、动态循环  -->
        <c:forEach items="${list}" var="str">
            ${str}<br />
        </c:forEach>
        
    <!--3、创建表格数据  -->
        <table border="1px">
            <tr>
                <td>课程名称</td>
                <td>教师</td>
                <td>价格</td>
                <td>重要性</td>
            </tr>
            <c:forEach items="${list}" var="s">
                <tr>
                    <td>${s}</td>
                    <td>${s}</td>
                    <td>${s}</td>
                    <td>${s}</td>
                </tr>
            </c:forEach>
        </table>
        
    <!--5、遍历map集合  -->
        <c:forEach items="${map}" var="m">
            ${m.key}--${m.value} <br />
        </c:forEach>
    
    

    2-2、格式化标签库

    2-3、SQL标签库

    2-4、函数标签库

    2-5、XML标签库

    Filter

    作用:对服务器接受的请求资源和响应给浏览器的资源进行管理。保护servlet

    使用:创建一个实现了Filter接口的普通java类

    ​ 覆写接口的方法

    init方法:服务器启动即执行。资源初始化
    doFilter方法:拦截请求的方法,在此方法中可以对资源实现管理。
    	注意:需要手动对请求进行放行。chain.doFilter(request, response);
    destory方法:服务器关闭执行。
    
    

    ​ 在web.xml中配置过滤器

    <filter>
        <filter-name>myFilter</filter-name>
        <filter-class>com.bjsxt.filter.MyFilter</filter-class>
    </filter>
    
    <filter-mapping>
        <filter-name>myFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
    
        url-pattern:/*
            表示拦截所有的请求。
        url-pattern:*.do
            表示所有以.do结尾的请求。一般是用来进行模块拦截处理。
        url-pattern:/ts
            表示拦截指定url的请求。针对某个servlet的请求进行拦截,保护servlet。
    
    

    生命周期:
    ​ 服务器启动到服务器关闭。
    总结:
    ​ 过滤器程序员声明和配置,服务器根据请求中的uri信息调用。
    执行:
    ​ 浏览器发起请求到服务器,服务器接收到请求后,根据URI信息在web.xml中找到对应的
    ​ 过滤器执行doFilter方法,该方法对此次请求进行处理后如果符合要求则放行,放行后
    ​ 如果还有符合要求的过滤则继续进行过滤,找到执行对应的servlet进行请求处理。servlet对
    ​ 请求处理完毕后,也就service方法结束了。还需继续返回相应的doFilter方法继续执行。

    案例:
    ​ 统一编码格式设置。
    ​ session管理
    ​ 权限管理
    ​ 资源管理(统一水印,和谐词汇等等)

    Listener

    1、 什么是web监听器

    web监听器是一种Servlet中的特殊的类,它们能帮助开发者监听web中的特定事件,比如ServletContext,HttpSession,ServletRequest的创建和销毁;变量的创建、销毁和修改等。可以在某些动作前后增加处理,实现监控。

    ​ 监听对象:

    ServletContext:application,整个应用只存在一个
    
    HttpSession:session,针对每一个对话
    
    ServletRequest:request,针对每一个客户请求
    
    

    ​ 监听内容:创建、销毁、属性改变事件

    ​ 监听作用:可以在事件发生前、发生后进行一些处理,一般可以用来统计在线人数和在线用户、统计网站访问量、系统启动时初始化信息等。

    2 、用途

    通常使用Web监听器做以下的内容:

    统计在线人数,利用HttpSessionLisener

    加载初始化信息:利用ServletContextListener

    统计网站访问量

    实现访问监控

    3、监听器分类

    ​ 根据三个域对象上的具体操作,将监听器划分为三类
    a1.监听三个域对象的创建和销毁事件的监听器
    a2.监听域对象中属性的增加、删除、替换事件的监听器
    a3.监听绑定到HttpSession域中的某个对象的状态的监听器,又称为感知型监听器

    4、接口与方法

    监听对象 监听接口 监听事件
    ServletRequest ServletRequestListener
    ServletRequestAttributeListener
    ServletRequestEvent
    ServletRequestAttributeEvent
    HttpServlet HttpSessionListener
    HttpSessionActivationListener
    HttpSessionAttributeListener
    HttpSessionBindingListener
    HttpSessionEvent

    HttpSessionBindingEvent
    ServletContext ServletContextListener
    ServletContextAttributeListener
    ServletContextEvent
    ServletContextAttributeEvent
    ServletContextListener	:	在Servlet上下文对象初始化或销毁时得到通知
    ServletContextAttributeListener		:	在Servlet上下文中的属性列表发生变化时得到通知
    HttpSessionListener	:	在session创建后或者失效前得到通知
    HttpSessionActivationListener	:	绑定到session中,当session被钝化或者激活时得到通知
    HttpSessionAttributeListener	:	在session中的属性列表发生变化时得到通知
    HttpSessionBindingListener	:	在绑定session或从session中删除时会得到通知
    ServletRequestListener	:	在请求对象初始化时或者被销毁时得到通知
    ServletRequestAttributeListener	:	在请求对象中的属性列表发生变化时得到通知
    
    

    5、监听器配置

    ​ a1.使用注解 @WebListener
    ​ a2.使用web.xml中

    <listener>
    	<listener-class>com.zhiling.listener.SessionAttributeListener</listener-class>
    </listener>
    <context-param>
        <param-name>str</param-name>
        <param-value>Hello world</param-value>
    </context-param>
    
    

    AJAX

    异步刷新的技术

    作用

    a1.提高用户的体验,在不刷新页面的情况下,加载页面内容,只刷新局部页面的内容
    a2.有效利用带宽,减轻服务器的压力

    与传统差异
    a1.请求提交的方式不同:传统方式是浏览器同步提交请求,而ajax使用异步引擎对象提交请求
    a2.服务器响应不同:传统方式响应内容是一个完整页面;而ajax响应的是局部数据
    a3.客户端处理方式不同:需等待服务器响应完成并重新加载整个页面后用户才能进行操作; ajax不需要等待,服务器什么时候响应完数据,什么时候更新页面

    Ajax包括的技术:

    ajax异步引擎对象:XMLHttpRequest
    js,jQuery,css,html
    json数据格式
    
    

    XMLHttpRequest对象
    常用的方法

    open(); 与服务器建立连接
    setRequestHeader(); //设请求头信息
    send(); //发送请求
    
    

    常用的事件

    onreadystatechange=回调函数
    
    

    常用属性:

    readystate:就绪状态:为4
    status:200 
    responseText; 响应的文本
    
    

    原生Ajax实现异步请求的步骤:

    得到XMLHttpRequest
    设置回调函数编写回调函数更新页面局部内容
    使用open()与服务器建立连接
    设置请求头信息(只是post提交请求才需要此步,get无须设请求头信息)
    用send()发送请求
    
    

    2、jQuery—ajax

    2-1、$.ajax()

    $.ajax({
        url:"",		//发送请求的地址
        method:"POST|GET",	//HTTP请求方式
        async:"true|false",  //是否异步,默认为true异步
        contentType"application/x-www-form-urlencoded; charset=UTF-8",		//数据编码格式
        data:{name:xiaoming,age:13}|{"name":name,"age":age},	//提交的数据
        dataType:"",	//返回数据类型 xml,json,script,html,text
        success:function(data){
            alert(data);
        },	//成功回调函数 data接收到的数据
    });
    
    $.ajax({
        url:"",		//发送请求的地址
        method:"POST|GET",	//HTTP请求方式
        async:"true|false",  //是否异步,默认为true异步
        contentType"application/x-www-form-urlencoded; charset=UTF-8",		//数据编码格式
        data:{name:xiaoming,age:13}|{"name":name,"age":age},	//提交的数据
        dataType:"json",	//返回数据类型 xml,json,script,html,text
    }).done(function(data){
    	//若之前没有指定返回数据解析方式,使用下面方法转换成json对象
    	var json = JSON.parse(data);
        alert(data);	//成功响应回调函数
    });
    
    

    2-2、$.post()

    $.post(
    	//请求发送地址
    		"url",
        //提交的数据
    		{name:"xiaoming",age:13},	
    	//回调函数
    		function(data){
           		alert(data);	
    		},
    	//返回数据解析类型
    		"json"|"text"
    )
    
    

    2-3、$.get()

    $.get(
    	//请求发送地址
    		"url",
        //提交的数据
    		{name:"xiaoming",age:13},	
    	//回调函数
    		function(data){
           		alert(data);	//返回类型为json则是object 若是text则原样输出字符串
    		},
    	//返回数据解析类型
    		"json"|"text"
    )
    
    

    2-4、$getJSON

    2-5、$.load()

    3、JSON

    一种客户端与服务器端进行数据交换的数据格式

    var 变量名={key:value,key2:value,....}
    
    
    a1.定义一个JSON的对象:
    	例:var person = {"name":"兰海昊","sex":"男","age":20};
    a2.定义一个JSON的数组
    	例:var country=["中国","日本","美国"];
    a3.定义一个对象数组
    	var stuArray = [{"name":"兰海昊","sex":"男","age":20},{"name":"陈汉","sex":"男","age":21},{"name":"刘丹","sex":"女","age":22}];
    
    

    JSONObject 常用的方法:

    fromObject(Object);  //将java对象转成json的对象
    toBean(JSONObject); //将json的对象转成java对象
    Map<Integer,Student> stuMap = new HashMap<Integer,Student>();
    stuMap.put(100,new Student(100,"张三","男"));
    stuMap.put(101,new Student(101,"张a三","男"));
    stuMap.put(102,new Student(102,"张dsf三","男"));
    new gson().toJSON(map)	
    
    

    JS 对象(Object)和字符串(String)互转方法

    利用原生JSON对象,将对象转为字符串

    // 字符串转化为 对象
    var jsonString = '[{"name":"天鸽"},{"name":"梅花"},{"name":"台风"}]';
    
    // console.log(JSON.parse(jsonString));
    var jsArr = JSON.parse(jsonString);
    
    jsArr.push({"name":"帕卡"});
    
    console.log(jsArr);
    
    
    // 把js对象 数组 转化为 JSON格式的字符串
    var result = JSON.stringify(jsArr);
    
    console.log(result);
    
    

    软件开发流程

    可行性分析 软件销售,架构师,产品经理,UI设计
    ​ |
    ​ 需求分析 需求规格说明书.doc---->产品经理,系统分析师,架构师,项目经理
    ​ |
    ​ 概要设计 概要设计文档.doc—>>产品经理,系统分析师,架构师,项目经理
    ​ | UI
    ​ 详细设计 详细设计说明书.doc—>项目经理
    ​ 数据库设计文档.doc----->DBA
    ​ 项目原型 ------>前端开发工程师
    ​ 项目推进计划------->项目经理
    ​ |
    ​ 编码 开发人员
    ​ |
    ​ 测试 冒烟测试------>软件测试
    ​ 项目上线---->软件实施
    ​ |
    ​ 维护

    展开全文
  • Java和JavaEE区别

    千次阅读 2018-11-28 21:19:32
    Java和JavaEE区别: Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和...

    Java和JavaEE区别:

    1. Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网,同时拥有全球最大的开发者专业社群。正式成立于1995年,广泛应用于人们的生活、工作、娱乐等等方面。

    2. Java分为三个版本:Java SE(标准版)、Java EE(企业版)、Java ME(微型版)。其中JavaSE就是大家学JavaEE和JavaME的基础,换而言之学Java先从JavaSE开始,JavaSE 包含了支持 Java Web 服务开发的类,JavaEE是企业最常用的用于企业级开发应用的,Java ME主要是移动段的开发应用。

    3. 通过以上,Java和JavaEE的区别在哪,就特别的明显了。那么为什么很多培训主打JavaEE培训呢?是因为JavaEE在Java中,比JavaSE和JavaME应用更加广泛,价值更高,所以很多的培训机构就直接主打JavaEE培训,不过其他两个方面的Java知识也是要大致掌握的。

    展开全文
  • Eclipse(JavaEE)下载地址

    万次阅读 多人点赞 2019-07-07 19:41:27
    最近开发要用到Eclipse,整理一下下载地址 ... 选择你需要的版本,进去下载页面,在这里我选择Windows X64的,这时候不要着急下载,选择国内的镜像地址去下载 在这里我们选择中科大的源去下载,速度超级快 ...
  • JavaEE体系规范(全网最详细)

    千次阅读 2018-10-21 12:04:26
    使用java很多年,一开始的时候很深入的研究了一下javaSE,后来以为对java很了解了,现在发现还有太多的不了解,所以又从javaEE开始研究和总结,目的在于想对java有更深入的理解,也想在网上跟大家交流,如果总结出来...
  • JavaEE简介

    千次阅读 2019-02-11 14:52:18
    JavaEE(Java Enterprise Edition ): JavaEE本身是一个标准,一个为企业分布式应用开发提供的标准平台。 2018年3月,开源组织Eclipse基金会宣布Java EE被更名为Jakarta EE。 包括的技术领域 – Servlet,JSP,JSTL ...
  • JavaEE

    千次阅读 2018-07-23 09:43:45
    JavaEE是一套使用Java进行企业级Web应用开发的大家一致遵循的工业标准。  JavaEE平台提供了一个基于组件的方法来加快设计、开发、装配及部署企业应用程序。  相较于Microsoft的.NET,Sun公司的Ja...
  • jdk是java的开发工具包,jdk不分javaME, javaSE和javaEE   javaME,javaSE和javaEE是什么   网络上普遍认为javaME就是用来开发嵌入式的,javaSE就是用来开发桌面的,javaEE就是用来开发企业端的。这也许没错,...
  • javaee

    千次阅读 2019-02-23 11:31:23
    javaee
  • JAVAEE

    2016-12-18 12:54:43
    为什么需要JavaEE 我们编写的JSP代码中,由于大量的显示代码和业务逻辑混淆在一起,彼此嵌套,不利于程序的维护和扩展。当业务需求发生变化的时候,对于程序员和美工都是一个很重的负担。 为了程序的易维护性和可...
  • JavaEE知识体系梳理

    千次阅读 多人点赞 2019-06-16 16:08:02
    JavaEE介绍: JavaEE的13种核心技术规范: 1、JDBC(Java Database)数据库连接 2、JNDI(Java Naming and Directory Interfaces)Java 的命名和目录接口 3、EJB(Enterprise JavaBean) 4、RMI(Remote Method...
  • JAVAEE5 VS JAVAEE6

    千次阅读 2016-07-08 10:16:31
    Java EE 5 由 Java Community Process 通过 Java Specification Request 244 发布,这个 “总纲” JSR 指出了详细描述 Java EE 5 中各种技术的其他规范(参见 参考资料)。Sun Microsystems 的 Bill Shannon 领导一...
  • JavaEE介绍

    万次阅读 多人点赞 2009-09-05 19:32:00
    1、 为什么需要JavaEE我们编写的JSP代码中,由于大量的显示代码和业务逻辑混淆在一起,彼此嵌套,不利于程序的维护和扩展。当业务需求发生变化的时候,对于程序员和美工都是一个很重的负担。为了程序的易维护性和可...
  • JavaEE全套API

    2018-10-21 19:05:28
    JavaEE全套API W3CSchool.chm bootstrap3中文文档 Cascading Style Sheet 样式表中文手册 HtmlHelp.chm dom4j.chm JQuery.chm HTTP1.1.chm ajax.chm XPathTutorial.chm XML指南.chm xsd.chm DTD.chm 正则表达式 ...
  • IntelliJ IDEA 2017 创建JavaEE项目

    万次阅读 多人点赞 2017-04-16 22:05:19
    IntelliJ IDEA 2017创建JavaEE项目...本博文是博主今天使用的这款完全陌生的IDE的痛苦探索过程,本文简单介绍了一种新的IDE : IntelliJ 来开发JavaEE或者Web,将会给你带来全新的体验哦,由于本博主也是个这款IDE初来
  • JavaEE音乐网站

    2019-03-24 22:48:09
    这是一个Bootstrap+SpringBoot的JavaEE项目,将当下流行的前后端框架结合在一起,模拟网易云音乐实现对音乐的基本操作。 完成对音乐的播放、上传、下载、删除、推荐、搜索、评论、点赞 完成用户的注册、登录、注销、...
  • javaee5源代码

    千次下载 热门讨论 2009-09-14 23:56:18
    可在 eclipse 中查看 java javaee 源码java javaee 源码java javaee 源码java javaee 源码java javaee 源码java javaee 源码java javaee 源码java javaee 源码
1 2 3 4 5 ... 20
收藏数 164,590
精华内容 65,836
关键字:

javaee