J2EE学习笔记_j2ee笔记-CSDN博客

本文链接：https://blog.csdn.net/dyccsxg/article/details/3555142

J2EE学习笔记

一、 基本概念（J2EE Java 2 Enterprise Edition ）

1. web 构件：在J2EE Web 容器上运行的软件程序，Web 容器主要支持多层结构的表示层。

容器是能提供基本功能的底层平台，他们之间通过接口进行通信；

构件和容器的关系有些像计算机插件和主板的关系；

Web 程序的体系结构：双层结构、三层结构、多层结构（用户界面层、表示逻辑层、业务层、数据访问层、数据层）；

Web 容器管理所有JSP、JSTL、和Servlet等web 构件的运行，这一层对应多层结构中的表示层；

2. web 构件的功能：在HTTP协议上对web 请求（request）进行响应（response）;

所谓响应：就是动态生成的网页。

3. J2EE 的web 构件包括：servlet 、JSP、JSTL（Java Server Pages Standard Tag Library）；

4. Web 程序客户端的主要功能：

（1）显示用户界面；

（2）确认用户输入；

（3）与服务器进行通信；

（4）管理对话状态；

5. 浏览器的主要功能：

（1）以特定状态显示HTML文件

（2）获取用户的点击并转化为web 请求request

（3）连接web服务器，发出web请求并接收处理响应

（4）管理用户与服务器之间的对话状态session state

6. GET 方法：简单直观，数据连接在URL 之后；

缺点：保密性不好，URL长度受限；

POST方法：数据和URL 分开发送；

MIME类型文件、自动使用Post方法

ENCTYPE：指定数据在发送之前的编码方式；

7. web 层的功能：用来处理HTTP请求，根据web容器内的servlet 和JSP动态生成HTTP响应

8. servlet 的优点：（1）方便灵活；（2）高效的；（3）通用廉价；

9. JSP的优点：

（1）JSP是从servlet 发展而来的；

（2）简单易用；

（3）方便开发；

（4）功能强大；

10. session ：代表一个客户在一段工作过程中对web 服务器的一系列web 请求；

11. Cookie ：web 服务器向浏览器发送的并在客户端存储的微型数据文件，限制大小为4 KB；

（以 key 、 value 方法存储信息）

12. web 容器实现会话的三种方式

（1）Cookie 机制；

（2）URL 重写；将会话代码加入URL 的过程成为URL 重写；

（3）隐藏表单输入；

13. 请求转发和请求重定向的区别：

进行请求转发时，存储在request 对象中的信息会被保留并被带到目标页面中；

而重定向是重新生成一个 request 请求，然后将该请求重定向到指定的url ，所以事先存储在request 对象中的信息都不存在了；

14．Ajax 包括的5中技术：XMLHTTPRequest，javascript、DOM、CSS、XML;

二、 servlet

1. JSP 和servlet 的区别：

（1）编程方式不同；

（2）servlet 必须在编译以后才能执行；

（3）运行速度不同；

2. servlet 的生命周期

（1）当web 客户请求servlet 服务或当web 服务启动时，容器环境加载一个Java Servlet 类；

（2）容器环境也将根据客户请求创建一个Servlet 对象实例，或者创建多个Servlet 对象实例，并把这些实例加入到Servlet 实例池中；

（3）容器环境调用Servlet 的初始化方法HttpServlet.init() 进行初始化；

（4）容器环境利用一个HttpServletRequest 和HttpServletResponse 对象，封装从web 客户接收到的HTTP请求和由Servlet 生成的响应；

（5）容器环境把HttpServletRequest 和HttpServletResponse 对象传递给HttpServlet.service()方法；

（6）定制的Java Servlet 从HttpServletRequest对象读取HTTP请求数据，访问来自HttpSession 或Cookie 对象的状态信息，进行特定应用的处理，并利用HttpServletResponse 对象生成HTTP响应数据；

（7）当web 服务器或容器关闭时，会自动调用HttpServlet.destroy() 方法关闭所有打开的资源，并进行一些关闭前的处理。

3. Servlet 开发步骤：

（1）继承HttpServlet 抽象类；

（2）重写父类方法 public void init() throws ServletException

protected void doGet(HttpServletRequest req,HttpServletResponse resp)

throws ServletException, java.io.IOException

protected void doPost(HttpServletRequest request,HttpServletResponse response)

throws ServletException, java.io.IOException

public void destroy()

（3）如果有HTTP请求信息，获取该信息；

（4）生成HTTP响应；

Servlet 配置

（1） Servlet 名称、类和其他选项配置

<description>servlet 的描述信息</description>

<display-name>发布时servlet 的名称</display-name>

<servlet-name>HelloServlet</servlet-name>

<servlet-class>upc.HelloServlet</servlet-class>

</servlet>

如果要配置的servlet 是一个JSP页面则使用<jsp-file>login.jsp</jsp-file> 来指定

（2）初始化参数

<init-param>

<param-name>driver</param-name>

<param-value>com.mysql.jdbc.Driver</param-value>

</init-param>

</servlet>

上述参数在servlet 中可以通过String driver=getInitParameter(“driver”);方法获取

（3）启动装入优先权

<load-on-startup>10</load-on-startup>

（4） Servlet 的映射

<servlet-mapping>

<servlet-name>HelloServlet</servlet-name>

<url-pattern>/servlet/HelloServlet</url-pattern>

</servlet-mapping>

4. servlet 相关技术

(1) 向页面输出内容

PrintWriter out=response.getWriter();

out.println(“Hello world!”);

（2）转交web 请求：

HttpServletResponse的方法sendRedirect(java.lang.String location);

RequestDispatcher

dispatcher = getServletContext() .getContext(“/webapp2”)

.getRequestDispatcher (“/servlet2”);

5. 过滤器

（1）过滤器：是能够对请求和响应的头属性（header）和内容体（body）进行操作的特殊web构件。

（2）过滤器的主要功能：

★：对web 请求进行分析，对输入数据进行预处理；

★：阻止请求和响应的进行；

★：根据功能改动请求的头信息和数据体；

★：根据功能改动响应的头信息和数据体；

★：和其他web 资源进行协作；

（3）过滤器的使用方法：

过滤器要实现javax.servlet.Filter 接口；

该接口有init()、destroy()、doFilter等方法；

destroy方法当web 容器要将过滤器从内存中清除时被调用；

doFilter（）方法在过滤器每次被激活时被调用；

示例：

public final class SimpleFilter implements Filter{

private FilterConfig fconfig=null;

public void init(FilterConfig config)throws ServletException{

this.fconfig=config;

}

public void destroy(){

this.config=null;

}

public void doFilter(ServletRequest req,ServletResponse resp,FilterChain chain)

throws ServletException,IOException{

HttpServletRequest request=(HttpServletRequest)req;//强制转换

HttpServletResponse response=(HttpServletResponse)resp;

.........

chain.doFilter(request,response);//转发

.........

}

（4）过滤器的配置信息

<filter>

<filter-name>SimpleFilter</filter-name>

<filter-class>upc.SimpleFilter</filter-class>

<icon>filter.jpg</icon>

<display-name>a simple Filter</display-name>

<description>This is a filter sample</description>

<init-param>

<param-name>param1</param-name>

<param-value>value1</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>SimpleFilter</filter-name>

<url-pattern>/path/index.jsp</url-pattern>

</filter-mapping>

三、 JSP 技术

1. JSP 技术的三个部分：

（1）JSP 定义了一套文本方式的动态网页开发语言，用来描述web 服务器端如何处理web 请求和建立web 响应；

（2）JSP 可以实现管理web 服务器端对象的编程机制；

（3）JSP 技术还允许编程者可以对JSP 语言进行拓展；

2. JSP 的使用步骤：转换编译阶段和请求处理阶段；

转换是指将JSP 转化成JavaServlet程序；编译是指将Java源文件转化成类文件；

3．JSP 语法

一个JSP 文件包括模板数据和JSP 元素。

模板数据：是指JSP 中存在HTML 或XML文本，web容器在转换JSP时直接将模板数据作为响应输出。

JSP元素：是动态部分，包括四类：

directive（指示符）、

Scripting Elements（脚本元素）、

Comments（注释）、

Actions（动作）；

4. JSP 元素

元素类型	JSP语法格式	XML语法格式
Directives
Include Direvtive	<%@ include file=”relativeURL”%>	<jsp:directive.include file=””/>
Page Directive	<%@ page language=”java” ...%>	<jsp:directive.page ... />
Taglib Directive	<%@ taglib prefix=”” uri=”” %>	无参见<jsp：root>
Scripting Elements
Declarations	<%! declarations %>	<jsp:declaration>...</jsp:declaration>
Expressions	<%=expression%>	<jsp:expression>...</jsp:expression>
Scriptlet	<% code fragment%>	<jsp:scriptlet>...</jsp:scriptlet>
Comments	<%--comments--%>	无
Actions
<jsp:forward>	<jsp:forward page=””/>
<jsp:setProperty>	<jsp:setProperty name=”...” property=”...”/>	相同
<jsp:getProperty>	<jsp:getProperty name=”...” Property=”...”/>	相同
<jsp:param>	<jsp:param name=”” value=””/>	相同
<jsp:include>	<jsp:include page=”...” Flush=”...”/>	相同
<jsp:plugin>	<jsp:plugin ...>... </jsp:plugin>	相同
<jsp:useBean>	<jsp:useBean id=”...” Class=”...” Scope=”...” />	相同
其他
<jsp:root>	无	<jsp:root>...</jsp:root>
<jsp:text>	无	<jsp:text>...</jsp:text>

5. include 指令和<jsp:include>动作元素的区别：

（1）属性：

include指令通过file属性来指定被包含的页面，该属性不支持JSP中的表达式和struts应用中的请求模式（如*.do）

<jsp:include>动作元素通过page属性指定被包含的页面，该属性支持JSP中的表达式和Struts应用中请求模式

（2）处理方式

使用include 指令被包含的文件，它的内容会原封不动地插入到包含页中使用该指令的位置，然后JSP编译器再对这个合成的文件进行翻译；

使用<jsp:include>动作元素包含文件，当该标识被执行时，程序会将请求转发到（是转发而不是重定向）被包含的页面，并将执行结果输出到浏览器中，然后返回包含页继续执行后面的代码；

（3）包含方式

Include指令是静态包含方式，适用于被包含文件内容固定不变；

<jsp:include>是动态包含方式，用来包含经常需要改动的文件；

6. JSP 中作用范围

（1）page 范围：指一个JSP ，只有当前JSP 可以获得page对象及其属性；

（2）request 范围：指单个web请求，所有处理该请求的JSP都可以获得request对象及其属性；

（3）session 范围：指一系列JSP组成的会话，所有会话内的JSP都可以获得session对象及其属性；

（4）application 范围：指整个web 程序，一个web程序中的所有JSP都可以获得application对象及其属性；

7. JSP 中的9个隐含对象

（1）out 输出对象：

out.print(数据类型)或out.println(数据类型)；

out.newLine();

out.flush();

out.close();

out.clearBuffer();

out.clear(); //清楚屏幕显示数据

out.getBufferSize();

out.getRemaining();

out.isAutoFlush();

（2）page 对象：

（3）request 对象：

getAttribute（String name）；

getAttributeNames（）；

getCookies（）；

setAttribute（String name,java.lang.Object obj）;

（4）response 对象：

addCookie(Cookie cook);

sendRedirect(String location);

setContentType(String contentType);

getWriter();

（5） session 对象

setAttribute(String name,Object value);

getAttribute(String name);

getAttributeNames();

getId();

invalidate();

（6） application对象

（7）config对象：

（8）pageContext对象：

getRequest();

getResponse();

invalidate();

（9）exception对象

getMessage（）；

getLocalizedMessage（）；

printStackTrace（）；

toString（）；

fillInStackTrace（）；

四、Custom Tag

1. 开发方法：

（1）采用特定的API编写实现标记处理的程序；

（2）建立一个tag library descriptor(tld)文件，用来描述CustomTag

2. CustomTag分类：

根据格式及复杂程度可分为：简单标记、带属性标记、带标记体标记；

3. 标记处理程序必须实现tag handler 对象，具体为4个借口或3个类：

接口	方法
SimpleTag	doTag
Tag	doStartTag,doEndTag,release
IterationTag	doStartTag,doAfterBody,doEndTag,release
BodyTag	doStartTag,doEndTag,release,doInitBody,doAfterBody

3个类：TagSupport、BodyTagSupport、SimpleTagSupport；

4. tld 文件

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE taglib PUBLIC "-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"

"http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd">

<tlib-version>1.0</tlib-version>

<jsp-version>1.2</jsp-version>

<short-name>upc</short-name>

<uri>http://localhost/upc</uri>

<tag>

<tag-class>upc.TagUpc</tag-class>

<body-content>empty</body-content>

</tag>

</taglib>

5. 标记处理程序

public class TagUpc implements Tag{

public int doStartTag() throws JspException {

try {

SimpleDateFormat format=new SimpleDateFormat("HH:mm:ss");

pagecontext.getOut().println("Hello 现在是下午了<br>"+format.format(new Date()));

} catch (IOException e) {

e.printStackTrace();

}

return SKIP_BODY;

}

public int doEndTag() throws JspException {

return EVAL_PAGE;

}

public void release() {

}

public void setPageContext(PageContext pc) {

this.pagecontext=pc;

}

public void setParent(Tag t) {

this.parent=t;

}

public Tag getParent() {

return this.parent;

}

private Tag parent;

private PageContext pagecontext;

}

6. JSP 中使用

<%@ taglib prefix="upc" uri="/WEB-INF/upc.tld"%>

<upc:time/><br>

五、JSTL

1. 表达式标签

（1）<c:out value=”value” [escapeXml=”true|false”][default=”defaultValue”]/>

（2）<c:set var=”name” value=”value” [scope=”page|request|session|application”]/>

（3）<c:remove var=”name” [scope=”page|request|session|application”]/>

（4）<c:catch [var=”name”]>

</c:catch>

2. 流程控制标签

（1）<c:if test=”condition” var=”name” [scope=”page|request|session|application”]>

标签主体

</c:if>

（2）<c:choose>

<c:when test=”condition”>...</c:when>

...

<c:otherwise>

...

</c:otherwise>

</c:choose>

3. 循环标签

（1）<c:forEach var=”name” items=”data” begin=”start” end=”finish” step=”step”

varStatus=”statusName”>

...

</c:forEach>

六、Struts 技术

1. Struts 框架是目前非常流行的基于Java技术开发的JSP Web 应用开发框架；

2. Struts 1.2 的 /WEB-INF/web.xml 配置

<servlet-name>action</servlet-name>

<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

<init-param>

<param-name>config</param-name>

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<init-param>

<param-name>debug</param-name>

<param-value>3</param-value>

</init-param>

<init-param>

<param-name>detail</param-name>

<param-value>3</param-value>

</init-param>

<load-on-startup>0</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

4. struts 1.2 的 /WEB-INF/struts-config.xml 配置

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.2//EN" "http://struts.apache.org/dtds/struts-config_1_2.dtd">

<struts-config>

<data-sources>

</data-sources>

<form-beans >

<form-bean name="loginActionForm" type="upc.LoginActionForm"/>

</form-beans>

<global-exceptions />

<global-forwards />

<action-mappings>

type="upc.LoginAction"

name="loginActionForm"

scope="session"

attribute="login"

validate="true"

input="/fail.jsp"

>

</action>

</action-mappings>

<message-resources parameter="com.yourcompany.struts.ApplicationResources" />

</struts-config>

5. struts 1.2 的ActionForm 类必须继承org.apache.struts.action.ActionForm 类；

Action 类必须继承org.apache.struts.action.Action 类；

且必须实现父类中的execute（）方法

public ActionForward execute(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)

throws Exception {...

return mapping.findForward("success");

}

6. struts 2.0 的/WEB-INF/web.xml 配置

<filter-name>struts2</filter-name>

<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>

</filter>

<filter-mapping>

<filter-name>struts2</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

7. struts 2.0 的 /src/struts.xml 配置

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE struts PUBLIC

"-//Apache Software Foundation//DTD Struts Configuration 2.0//EN"

"http://struts.apache.org/dtds/struts-2.0.dtd">

<result name="success">/success.jsp</result>

<result name="failure">/failure.jsp</result>

</action>

</package>

</struts>

8. struts 2.0 的Action 类可以继承com.opensymphony.xwork2.ActionSupport 类，并实现父类的execute()方法：

public String execute() throws Exception {

if(username.equals("upc") && password.equals("edu")){

return "success";

}

return "failure";

}

也可以不继承ActionSupport类，但Action类中必须有execute（）方法，如下所示：

public String execute() throws Exception {...}

七、Spring 技术

1. IoC （Inversion of Control）控制反转：由容器控制程序之间关系，而非代码控制，控制权的转移即反转；

2. 配置文件：src/applicationContext.xml

<?xml version=”1.0” encoding=”utf-8”?>

<!DOCTYPE beans PUBLIC “-//SPRING/DTD BEAN//EN”

“http://www.springframework.org/dtd/spring-beans.dtd”>

<beans>

</property>

</bean>

</beans>

10.使用

ApplicationContext context=new ClassPathXmlApplicationContext(“applicationContext.xml”);

Message msg=(Message)context.getBean(“message”);

4. 开发Spring 应用程序的步骤：

<1>编写控制器类

<2>编写部署描述文件，使web 构件映射到控制器类

<3>程序的发布

导包

Spring.jar （dist 目录中）

commons-logging.jar ( lib / jakarta-commons 目录中)

dom4j-1.6.1 （lib / dom4j 目录中）

配置 src / beans-config.xml

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING/DTD BEAN/EN"

"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<value>Hello the world</value>

</property>

</bean>

</beans>

控制类 TSpring / src / upc.HelloBean.java

ApplicationContext context=new ClassPathXmlApplicationContext("beans-config.xml");

HelloBean hello=(HelloBean)context.getBean("hellobean");

System.out.println(hello.getHelloWorld());

注：工程目录为 TSpring / src /beans-config.xml

使用File 时是从 TSpring 目录中找起

File file=new File("src/beans-config.xml");

使用 ClassPathXmlApplicationContext() 是从 src 目录中找起

ClassPathXmlApplicationContext("beans-config.xml");

八、Hibernate 技术

1. Hibernate 开发步骤：

（1）持久化类的设计；

（2）持久化类和关系数据库的映射；

（3）应用的开发；

2. 使用步骤：

Configuration config=new Configuration().configure();

SessionFactory sf=config.buildSessionFactory();

Session session=sf.openSession();

Transaction tx=session.beginTransaction();

Person person=new Person();

person.setId(1);

person.setName(“ss”);

Session.save(person);

tx.commit();

session.close();

3. 。。。