java语言体系的技术简介之JSP、Servlet、JDBC、JavaBean(Application)

阅读量：6582 次

发布时间：2019-06-24

本文共 12900 字，大约阅读时间需要 43 分钟。

转自：https://zhangkunnan.iteye.com/blog/2040462

前言

Java语言

Java语言体系比较庞大，包括多个模块。从WEB项目应用角度讲有JSP、Servlet、JDBC、EJB四部分技术。其中还有其他的9个技术规范（JNDI，）

正文

Java Database Connectivity (JDBC)技术

JDBC(Java Database Connectivity) 是一种用于执行 SQL 语句的 Java API。它由一组用 Java 编程语言编写的类和接口组成。JDBC 为工具/数据库开发人员提供了一个标准的API，使他们能够用纯Java API 来编写数据库应用程序。

简单地说，JDBC 可做三件事：

l 与数据库建立连接，

l 发送 SQL 语句，

l 处理结果。

Servlet技术

Servlet是运行在服务器端的程序，可以被认为是服务器端的applet。servlet被Web服务器（例如Tomcat）加载和执行，就如同applet被浏览器加载和执行一样。servlet从客户端(通过Web服务器)接收请求，执行某种操作，然后返回结果。

Servlet是服务端的Java应用程序，可以生成动态的页面，在客户端Session中保存客户的数据。它定义了动态生成HTML、XML或其他格式文档的Web网页的技术标准。

Servlet的主要优点包括

l Servlet是持久的。servlet只需Web服务器加载一次，而且可以在不同请求之间保持服务(例如一次数据库连接)。

l Servlet是与平台无关的。如前所述，servlet是用Java编写的，它自然也继承了Java的平台无关性。

l Servlet是可扩展的。由于servlet是用Java编写的，它就具备了Java所能带来的所有优点。Java是健壮的、面向对象的编程语言，它很容易扩展以适应你的需求。servlet自然也具备了这些特征。

l Servlet是安全的。从外界调用一个servlet的惟一方法就是通过Web服务器。这提供了高水平的安全性保障，尤其是在你的Web服务器有防火墙保护的时候。

l Servlet可以在多种多样的客户机上使用。由于servlet是用Java编写的，所以你可以很方便地在HTML中使用它们。

JavaServer Pages(JSP) 技术

JSP是从Servlet上分离出来的一小部分，简化了开发，加强了界面设计。JSP定位在交互网页的开发。运用Java语法，但功能较Servlet弱了很多，并且高级开发中只充当用户界面部分。JSP容器收到客户端发出的请求时，首先执行其中的程序片段，然后将执行结果以HTML格式响应给客户端。其中程序片段可以是：操作数据库、重新定向网页以及发送 E-Mail 等等，这些都是建立动态网站所需要的功能。所有程序操作都在服务器端执行，网络上传送给客户端的仅是得到的结果，与客户端的浏览器无关，因此，JSP 称为Server-Side Language。

JavaServer Pages的主要优点包括

●一次编写，各处执行(Write Once, Run Anywhere)特性

作为Java 平台的一部分，JavaServer Pages 技术拥有Java语言“一次编写，各处执行”的特点。随着越来越多的供货商将JavaServer Pages 技术添加到他们的产品中，您可以针对自己公司的需求，做出审慎评估后，选择符合公司成本及规模的服务器，假若未来的需求有所变更时，更换服务器平台并不影响之前所投下的成本、人力所开发的应用程序。

● 搭配可重复使用的组件

JavaServer Pages技术可依赖于重复使用跨平台的组件（如：JavaBean或Enterprise JavaBean组件）来执行更复杂的运算、数据处理。开发人员能够共享开发完成的组件，或者能够加强这些组件的功能，让更多用户或是客户团体使用。基于善加利用组件的方法，可以加快整体开发过程，也大大降低公司的开发成本和人力。

● 采用标签化页面开发

Web 网页开发人员不一定都是熟悉Java 语言的程序员。因此，JSP 技术能够将许多功能封装起来，成为一个自定义的标签，这些功能是完全根据XML 的标准来制订的，即JSP 技术中的标签库(Tag Library)。因此，Web 页面开发人员可以运用自定义好的标签来达成工作需求，而无须再写复杂的Java 语法，让Web 页面开发人员亦能快速开发出一动态内容网页。

今后，第三方开发人员和其他人员可以为常用功能建立自己的标签库，让Web 网页开发人员能够使用熟悉的开发工具，如同HTML 一样的标签语法来执行特定功能的工作。

● N-tier 企业应用架构的支持

有鉴于网际网络的发展，为因应未来服务越来越繁杂的要求，且不再受地域的限制，因此，

必须放弃以往Client-Server的Two-tier 架构，进而转向更具威力、弹性的分散性对象系统。由于JavaServer Page 技术是Java 2 Platform Enterprise Edition (J2EE)集成中的一部分，它主要是负责前端显示经过复杂运算后之结果内容，而分散性的对象系统则是主要依赖EJB ( Enterprise JavaBean )和JNDI ( Java Naming and Directory Interface )构建而成。

JSP页面有HTML代码和嵌入其中的Java代码组成。它将网页逻辑与网页设计显示分离，支持可重用的基于组件的设计，是的java开发快速、容易。JSP是一种动态页面技术，它主要目的是将表示逻辑从Servlet中分离出来。

EnterpriseJavaBean(Application)应用组件技术

Application是Java应用程序，在WEB项目和一些开发中主要应用JavaBean。它就是Application的一部分，逻辑运算能力很强，能极大的发挥Java语言的优点。JavaBean 的结构必须满足一定的命名约定。JavaBean能提供常用功能并且可以重复使用，这使得开发人员可以把某些关键功能和核心算法提取出来封装成为一个组件对象，这样就增加了代码的重用率和系统的安全性。

EJB是实现分布式业务逻辑的Java组件。它以一个标准自动处理了如数据持久化、事务集成、安全对策等问题，为后台业务提供了一个标准方式。

EJB规范讨论了四中对象类型：无状态会话bean、有状态会话bean、实体bean、消息驱动bean。

1)Stateless Session Beans是一类不包含状态信息的分布式对象，允许来自多个客户端的并发访问。无状态回话Bean没有资源集约性，访问的实例变量内容页不会被保存。举个例子：一个发送邮件的EJB就可以设计为一个无状态回话Bean。整个会话期，用户指向服务器提交一个动作：发送指定邮件到我的地址。

2)Stateful Session Beans是包含状态的实例对象。比如在淘宝买完东西结账时，就需要一个有状态会话bean，因为服务器必须随时了解用户进行到了哪一步。尽管有状态会话bean可以被保存，但始终只能同时由一个用户来访问。

JNDI是一个Java应用程序设计接口，它为我们提供了查找和访问各种命名和目录服务的通用、统一方式。JNDI避免了程序与数据库之间的紧耦合，使应用更加易于配置，便于部署。

JNDI的扩展：JNDI在满足了数据源配置的要求的基础上，还进一步扩充了作用：所有与系统外部的资源的引用（资源引用、环境实体和 EJB 引用），都可以通过JNDI定义和引用。

官方文档参考：apache-tomcat-6.0.36\webapps\docs\jndi-datasource-examples-howto.html

博客参考：http://blog.csdn.net/zhaosg198312/article/details/3979435

RMI：Remote Method Invocation，远程方法调用

RMI是一种机制，能够让在某个Java虚拟机上的对象调用另一个Java虚拟机中的对象上的方法，它使得客户机上运行的程序可以调用远程服务器上的对象。

大名鼎鼎的EJB都是建立在rmi基础之上的

参考：http://www.cnblogs.com/ninahan0419/archive/2009/06/25/javarmi.html#top上面有详细的rmi示例程序代码

Java IDL/CORBA：Java Interface Definiyion Language/Common Object Request Broker Architecture ，Java接口定义语言/公用对象请求代理程序体系结构

CORBA是一个分布式的面向对象应用架构规范，定义了分布式对象如何实现互操作。CORBA对象的接口使用IDL语言来定义。对象的接口定义了对象的类型，对象的方法和引用参数以及对象方法可能返回的异常结果。

XML：Extensible Markup Language，可扩展标记语言

它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言.用于存储和传输数据。

JMS：Java Message Service，Java消息服务

JMS是java平台上有关面向消息中间件的技术规范。

JMS对象模型包含六个要素：连接工厂、JMS连接、JMS会话、JMS目的、JMS生产者和消费者、JMS消息类型（点对点、发布/订阅）。

连接工厂：由管理员创建，绑定到JNDI树种。客户端使用JNDI查找连接工厂，然后利用连接工厂创建一个JMS连接。

JMS连接：JMS会话表示JMS客户与JMS服务器之间的会话状态。JMS会话建立在JMS连接上，表示客户与服务器之间的一个会话线程。

JMS目的：消息队列，是实际的消息源。

生产者和消费者：由Session对象创建，用于发送和接受消息。

点对点消息类型：消息发送给一个单独的使用者。

发布/订阅消息类型：支持一个事件驱动模型，生产者和消费者都残余消息的传递。、

JTA：Java Transaction API，Java事务API

JTA允许应用程序执行分布式事务处理，在多个网络计算机资源上访问并且更新数据，极大地增强了数据访问能力。

JTS：Java Transaction Service，Java事务服务

JTS是一个组件事务监视器。JTS和JTA为J2EE提供了分布式事务服务。

JavaMail

为我们提供了电子邮件的开发接口。它可以方便的执行一些常用的邮件传输。JavaMail包中用于处理电子邮件的核心类是：Session,Message,Address,Authenticator,Transport,Store,Folder等。Session定义了一个基本的邮件会话，它需要从Properties中读取类似于邮件服务器，用户名和密码等信息。

JAF：JavaBeans Activation Framework，JavaBeans活动床架

JAF是一个专用的数据处理框架，它用于封装数据，并为应用程序访问和操作数据的接口。JFA主要作用在于让Java应用层序知道如何对一个数据源进行查看、编辑和打印等操作。

应用程序通过JAF提供的接口可以完成：访问数据源中的数据、获取数据源数据类型、获知可对数据进行的操作、用户执行操作时，自动创建该操作的软件部件的实例对象。

总结

谈谈我一个论坛项目使用到的jndi技术

首先建议大家尽量去看官方文档。在这里我就来谈谈我一个论坛项目使用到的jndi技术。

1. MySQL configuration

Source Database: bbs

Target Host: localhost

Target Database: bbs

2. Context configuration

Configure the JNDI DataSource in Tomcat by adding a declaration for your resource to your Context.

C:\Program Files\apache-tomcat-6.0.36\conf下的文件context.xml的配置如下：

                                          
<?xml version="1.0" encoding="UTF-8" ?> 
<!-- The contents of this file will be loaded for each web application -->
<Context>
<!-- Default set of monitored resources -->
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<!-- Uncomment this to disable session persistence across Tomcat restarts -->
<!--
 <Manager pathname="" />
 -->
<!-- Uncomment this to enable Comet connection tacking (provides events
 on session expiration as well as webapp lifecycle) -->
<!--
 <Valve className="org.apache.catalina.valves.CometConnectionManagerValve" />
 -->
<Resource name="jdbc/myblog" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="root" password="root" driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/myblog?autoReconnect=true"/>
</Context>
             
           

context.xml

3.获取数据源和定义sqlc的curd

文件/MyBBS/src/com/zjjy/dao/impl/BaseDao.java如下：

                                       
package com.zjjy.dao.impl;
import java.sql.SQLException;
import java.util.List;
import javax.naming.Context;//此接口表示一个命名上下文，它由一组名称到对象的绑定组成。
import javax.naming.InitialContext;//此类是执行命名操作的初始上下文
import javax.naming.NamingException;
import javax.sql.DataSource;//DataSource 接口由驱动程序供应商实现
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
/**
 * 
 * @author 张坤楠
 *获取数据源和定义sqlc的curd
 */
public class BaseDao { 
private static DataSource ds = null;
private static DataSource getDataSource() { 
if (ds == null) { 
try { 
/*
 * java:comp/env 是环境命名上下文（environment naming context（ENC）），是在EJB规范1.1以后引入的，引入这个是为了解决原来JNDI查找所引起的冲突问题，也是为了提高EJB或者J2EE应用的移植性。
 * ENC是一个引用，引用是用于定位企业应用程序的外部资源的逻辑名。
 * 引用是在应用程序部署描述符文件中定义的。在部署时，引用被绑定到目标可操作环境中资源的物理位置（JNDI名）。使用ENC是把对其它资源的JNDI查找的硬编码解脱出来，通过配置这个引用可以在不修改代码的情况下，将引用指向不同的EJB(JNDI)。 在J2EE中的引用常用的有： 
---------JDBC 数据源引用在java:comp/env/jdbc 子上下文中声明 
---------JMS 连接工厂在java:comp/env/jms 子上下文中声明 
---------JavaMail 连接工厂在java:comp/env/mail 子上下文中声明 
---------URL 连接工厂在 java:comp/env/url子上下文中声明 
 */
Context initContext = new InitialContext();//构造一个初始上下文
Context envContext = (Context) initContext
.lookup("java:/comp/env");// Object lookup(String name)检索指定的对象 
ds = (DataSource) envContext.lookup("jdbc/myblog");//<Resource name="jdbc/myblog"
} catch (NamingException e) { 
e.printStackTrace();
}
}
return ds;
}
protected List findList(String sqlString, Class clazz) { 
List beans = null;
try { 
QueryRunner qr = new QueryRunner(getDataSource());
beans = (List) qr.query(sqlString, new BeanListHandler(clazz));
} catch (SQLException e) { 
e.printStackTrace();
}
return beans;
}
protected List findTotalList(String sqlString){ 
List beans=null;
try{ 
QueryRunner qr=new QueryRunner(getDataSource());
beans=(List)qr.query(sqlString,new MapListHandler());
}catch(SQLException e){ 
e.printStackTrace();
}
return beans;
}
protected Object findObject(String sqlString, Class clazz) { 
Object object = null;
try { 
QueryRunner qr = new QueryRunner(getDataSource());
object = qr.query(sqlString, new BeanHandler(clazz));
} catch (SQLException e) { 
e.printStackTrace();
}
return object;
}
protected int update(String sqlString) { 
int rows = 0;
try { 
QueryRunner qr = new QueryRunner(getDataSource());
rows = qr.update(sqlString);
} catch (SQLException e) { 
e.printStackTrace();
}
return rows;
}
}
            
          

BaseDao.java

4.dao层的数据操作

                                             
package com.zjjy.dao.impl;
import java.util.List;
import com.zjjy.dao.SubBoardDao;
import com.zjjy.vo.SubBoardBean;
/**
 * 
 * @author 张坤楠
 *dao层的数据操作
 */
public class SubBoardDaoJdbcImpl extends BaseDao implements SubBoardDao { 
@Override
public SubBoardBean findSubBoard(int subBoardId) { 
String sqlString = "select * from subBoard where subBoardId="
+ subBoardId;
return (SubBoardBean) this.findObject(sqlString, SubBoardBean.class);
}
}
              
            

SubBoardDaoJdbcImpl.java

jndi的官方参考：

                                          
                 1.MySQL configuration 
                 Ensure that you follow these instructions as variations can cause problems. 
                 Create a new test user, a new database and a single test table. Your MySQL user must have a password assigned. The driver will fail if you try to connect with an empty password. 
                 mysql> GRANT ALL PRIVILEGES ON *.* TO javauser@localhost 
                 -> IDENTIFIED BY 'javadude' WITH GRANT OPTION; 
                 mysql> create database javatest; 
                 mysql> use javatest; 
                 mysql> create table testdata ( 
                 -> id int not null auto_increment primary key, 
                 -> foo varchar(25), 
                 -> bar int); 
                 Note: the above user should be removed once testing is complete! 
                 Next insert some test data into the testdata table. 
                 mysql> insert into testdata values(null, 'hello', 12345); 
                 Query OK, 1 row affected (0.00 sec) 
                 mysql> select * from testdata; 
                 +----+-------+-------+ 
                 | ID | FOO | BAR | 
                 +----+-------+-------+ 
                 | 1 | hello | 12345 | 
                 +----+-------+-------+ 
                 1 row in set (0.00 sec) 
                 mysql> 
                 2. Context configuration 
                 Configure the JNDI DataSource in Tomcat by adding a declaration for your resource to your Context. 
                 For example: 
                 <Context> 
                 <!-- maxActive: Maximum number of database connections in pool. Make sure you 
                 configure your mysqld max_connections large enough to handle 
                 all of your db connections. Set to -1 for no limit. 
                 --> 
                 <!-- maxIdle: Maximum number of idle database connections to retain in pool. 
                 Set to -1 for no limit. See also the DBCP documentation on this 
                 and the minEvictableIdleTimeMillis configuration parameter. 
                 --> 
                 <!-- maxWait: Maximum time to wait for a database connection to become available 
                 in ms, in this example 10 seconds. An Exception is thrown if 
                 this timeout is exceeded. Set to -1 to wait indefinitely. 
                 --> 
                 <!-- username and password: MySQL username and password for database connections --> 
                 <!-- driverClassName: Class name for the old mm.mysql JDBC driver is 
                 org.gjt.mm.mysql.Driver - we recommend using Connector/J though. 
                 Class name for the official MySQL Connector/J driver is com.mysql.jdbc.Driver. 
                 --> 
                 <!-- url: The JDBC connection url for connecting to your MySQL database. 
                 --> 
                 <Resource name="jdbc/TestDB" auth="Container" type="javax.sql.DataSource" 
                 maxActive="100" maxIdle="30" maxWait="10000" 
                 username="javauser" password="javadude" driverClassName="com.mysql.jdbc.Driver" 
                 url="jdbc:mysql://localhost:3306/javatest"/> 
                 </Context> 
                 3. web.xml configuration 
                 Now create a WEB-INF/web.xml for this test application. 
                 <web-app xmlns="http://java.sun.com/xml/ns/j2ee" 
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
                 xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee 
                 http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd" 
                 version="2.4"> 
                 <description>MySQL Test App</description> 
                 <resource-ref> 
                 <description>DB Connection</description> 
                 <res-ref-name>jdbc/TestDB</res-ref-name> 
                 <res-type>javax.sql.DataSource</res-type> 
                 <res-auth>Container</res-auth> 
                 </resource-ref> 
                 </web-app> 
                 4. Test code 
                 Now create a simple test.jsp page for use later. 
                 <%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %> 
                 <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> 
                 <sql:query var="rs" dataSource="jdbc/TestDB"> 
                 select id, foo, bar from testdata 
                 </sql:query> 
                 <html> 
                 <head> 
                 <title>DB Test</title> 
                 </head> 
                 <body> 
                 <h2>Results</h2> 
                 <c:forEach var="row" items="${rs.rows}"> 
                 Foo ${row.foo}<br/> 
                 Bar ${row.bar}<br/> 
                 </c:forEach> 
                 </body> 
                 </html> 
                 That JSP page makes use of JSTL's SQL and Core taglibs. You can get it from Apache Tomcat Taglibs - Standard Tag Library project — just make sure you get a 1.1.x release. Once you have JSTL, copy jstl.jar and standard.jar to your web app's WEB-INF/lib directory. 
                 Finally deploy your web app into $CATALINA_BASE/webapps either as a warfile called DBTest.war or into a sub-directory called DBTest 
                 Once deployed, point a browser at http://localhost:8080/DBTest/test.jsp to view the fruits of your hard work. 
             
           