Java——采用DOM4J+单例模式实现XML文件的读取
最后更新于：2022-04-01 07:14:19
# Java——采用DOM4J+单例模式实现XML文件的读取
大家对XML并不陌生，它是一种可扩展标记语言，常常在项目中作为配置文件被使用。XML具有高度扩展性，只要遵循一定的规则，XML的可扩展性几乎是无限的，而且这种扩展并不以结构混乱或影响基础配置为代价。项目中合理的使用配置文件可以大大提高系统的可扩展性，在不改变核心代码的情况下，只需要改变配置文件就可以实现功能变更，这样也符合编程开闭原则。
但是我们把数据或者信息写到配置文件中，其他类或者模块要怎样读取呢？这时候我们就需要用到XML API。 DOM4Jj就是一个十分优秀的JavaXML API，具有性能优异、功能强大和极其易使用的特点，下面我们就以java程序连接Oracle数据库为例，简单看一下如何使用配置文件提高程序的可扩展性以及DOM4J如何读取配置文件。
未使用配置文件的程序
~~~
/*
* 封装数据库常用操作
*/
public class DbUtil {
/*
* 取得connection
*/
public static Connection getConnection(){
Connection conn=null;
try {
Class.forName("oracle.jdbc.driver.OracleDriver");
String url = "jdbc:oracle:thin:@localhost:1525:bjpowernode";
String username = "drp1";
String password = "drp1";
conn=DriverManager.getConnection(url, username, password);
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
}
~~~
我们可以看到上面代码中DriverName、url等信息都是都是写死在代码中的，如果数据库信息有变更的话我们必须修改DbUtil类，这样的程序扩展性极低，是不可取的。
我们可以把DriverName、url等信息保存到配置文件中，这样如果修改的话只需要修改配置文件就可以了，程序代码根本不需要修改。
~~~
<?xml version="1.0" encoding="UTF-8"?>
<config>
<db-info>
<driver-name>oracle.jdbc.driver.OracleDriver</driver-name>
<url>jdbc:oracle:thin:@localhost:1525:bjpowernode</url>
<user-name>drp1</user-name>
<password>drp1</password>
</db-info>
</config>
~~~
然后我们还需要建立一个配置信息类来用来存取我们的属性值
~~~
/*
* jdbc配置信息
*/
public class JdbcConfig {
private String driverName;
private String url;
private String userName;
private String password;
public String getDriverName() {
return driverName;
}
public void setDriverName(String driverName) {
this.driverName = driverName;
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
@Override
public String toString() {
// TODO Auto-generated method stub
return this.getClass().getName()+"{driverName:" + driverName + ",url:" + url + ",userName:" + userName + "}";
}
}
~~~
接下来就是用DOM4J读取XML信息，并把相应的属性值保存到JdbcConfig中
~~~
/*
* DOM4J+单例模式解析sys-config.xml文件
*/
public class XmlConfigReader {
//懒汉式（延迟加载lazy）
private static XmlConfigReader instance=null;
//保存jdbc相关配置信息
private JdbcConfig jdbcConfig=new JdbcConfig();
private XmlConfigReader(){
SAXReader reader=new SAXReader();
InputStream in=Thread.currentThread().getContextClassLoader().getResourceAsStream("sys-config.xml");
try {
Document doc=reader.read(in);
//取得jdbc相关配置信息
Element driverNameElt=(Element)doc.selectObject("/config/db-info/driver-name");
Element urlElt=(Element)doc.selectObject("/config/db-info/url");
Element userNameElt=(Element)doc.selectObject("/config/db-info/user-name");
Element passwordElt=(Element)doc.selectObject("/config/db-info/password");
//设置jdbc相关配置信息
jdbcConfig.setDriverName(driverNameElt.getStringValue());
jdbcConfig.setUrl(urlElt.getStringValue());
jdbcConfig.setUserName(userNameElt.getStringValue());
jdbcConfig.setPassword(passwordElt.getStringValue());
} catch (DocumentException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public static synchronized XmlConfigReader getInstance(){
if (instance==null){
instance=new XmlConfigReader();
}
return instance;
}
/*
* 返回jdbc相关配置
*/
public JdbcConfig getJdbcConfig(){
return jdbcConfig;
}
public static void main(String[] args){
JdbcConfig jdbcConfig=XmlConfigReader.getInstance().getJdbcConfig();
System.out.println(jdbcConfig);
}
}
~~~
然后我们的数据库操作类就可以使用XML文件中的属性值了
~~~
/*
* 封装数据库常用操作
*/
public class DbUtil {
/*
* 取得connection
*/
public static Connection getConnection(){
Connection conn=null;
try {
JdbcConfig jdbcConfig=XmlConfigReader.getInstance().getJdbcConfig();
Class.forName(jdbcConfig.getDriverName());
conn=DriverManager.getConnection(jdbcConfig.getUrl(), jdbcConfig.getUserName(), jdbcConfig.getPassword());
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
}
~~~
现在我们可以看出来DriverName、url等信息都是通过jdbcConfig直接获得的，而jdbcConfig中的数据是通过DOM4J读取的XML，这样数据库信息有变动我们只需要通过记事本修改XML文件整个系统就可以继续运行，真正做到了程序的可扩展，以不变应万变。
Tomcat+Servlet保存Cookie到浏览器
最后更新于：2022-04-01 07:14:16
# Tomcat+Servlet保存Cookie到浏览器
我们在访问一些大型购物网站的时候，都有添加到购物车这一项，而购物车里面的东西都是临时的，商品买完之后购物车里面的东西可能就没有价值了。如果把这些临时的东西都保存到服务器的话，无疑是一种资源浪费。因此今天我们就引入一个新名词Cookie，说是新名词其实一点也不陌生，我们电脑或者浏览器清理垃圾的时候都有轻触Cookie这一项。其实这就是我们访问一些网站的时候，开发者为了避免自己服务器压力，或者减少服务器的存储浪费，而把一些临时的与用户相关的文件或者信息保存到用户电脑上。
这样的技术是怎样实现的呢，这里我做了一个简单的实例，供大家参考。核心代码如下：
~~~
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class SetCookies extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{
Cookie c1=new Cookie("password","123");
response.addCookie(c1);
response.getWriter().println("add cookie success!");
}
}
~~~
~~~
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class ShowCookies extends HttpServlet{
public void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{
Cookie[] Cookies=request.getCookies();
for(int i=0;i<Cookies.length;i++){
Cookie c=Cookies[i];
response.getWriter().println(c.getName()+","+c.getValue());
}
}
}
~~~
配置文件：
~~~
<servlet>
<servlet-name>SetCookies</servlet-name>
<servlet-class>SetCookies</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>SetCookies</servlet-name>
<url-pattern>/SetCookies</url-pattern>
</servlet-mapping>
<servlet>
<servlet-name>ShowCookies</servlet-name>
<servlet-class>ShowCookies</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>ShowCookies</servlet-name>
<url-pattern>/ShowCookies</url-pattern>
</servlet-mapping>
~~~
运行效果：
原理很简单，其实到具体应用用到cookie的地方特别多，因此我们还需要多多实践，多多应用，多读交流，有不足之处请大家批评指正。
Java——用户激活邮件工具类
最后更新于：2022-04-01 07:14:14
# Java——用户激活邮件工具类
我们经常遇到在网站或者软件注册新用户时需要向我们的注册邮箱发送一封激活邮件，然后我们去邮箱点击激活连接后我们的用户名才能登陆，其过程是当我们注册成功后数据库已经存入该用户的相关信息，但是用户状态为不可用，所以这时候该用户名是不能正常使用的。因此系统需要向我们的注册邮箱发一封激活邮件，我们点击激活连接后系统会将数据库中用户状态字段更改为可用状态，至此用户激活成功，该用户可以正常使用。下面是实现过程：
为了方便起见我们还是编写一个发送邮箱工具类。
~~~
package cn.itcast.shop.utils;
import java.util.Properties;
import javax.mail.Authenticator;
import javax.mail.Message;
import javax.mail.Message.RecipientType;
import javax.mail.MessagingException;
import javax.mail.PasswordAuthentication;
import javax.mail.Session;
import javax.mail.Transport;
import javax.mail.internet.AddressException;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
/**
* 邮件发送工具类
* @author shx
*
*/
public class MailUitls {
/**
* 发送邮件的方法
* @param to :收件人
* @param code :激活码
*/
public static void sendMail(String to,String code){
/**
* 1.获得一个Session对象.
* 2.创建一个代表邮件的对象Message.
* 3.发送邮件Transport
*/
// 1.获得连接对象
Properties props = new Properties();
props.setProperty("mail.host", "localhost");
Session session = Session.getInstance(props, new Authenticator() {
@Override
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication("service@shop.com", "111");
}
});
// 2.创建邮件对象:
Message message = new MimeMessage(session);
// 设置发件人:
try {
message.setFrom(new InternetAddress("service@shop.com"));
// 设置收件人:
message.addRecipient(RecipientType.TO, new InternetAddress(to));
// 抄送 CC 密送BCC
// 设置标题
message.setSubject("来自官方激活邮件");
// 设置邮件正文:
message.setContent("<h1>官方激活邮件!点下面链接完成激活操作!</h1><h3><a href='http://192.168.24.162:8080/shop/user_active.action?code="+code+"'>http://192.168.24.162:8080/shop/user_active.action?code="+code+"</a></h3>", "text/html;charset=UTF-8");
// 3.发送邮件:
Transport.send(message);
} catch (AddressException e) {
e.printStackTrace();
} catch (MessagingException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
sendMail("aaa@shop.com","11111111111111");
}
}
~~~
Action：
~~~
/**
*
* 用户注册
*/
public String regist(){
userService.save(user);
this.addActionMessage("注册成功，情趣邮箱激活！");
return "msg";
}
/**
* 用户激活的方法
*/
public String active() {
// 根据激活码查询用户:
User existUser = userService.findByCode(user.getCode());
// 判断
if (existUser == null) {
// 激活码错误的
this.addActionMessage("激活失败:激活码错误!");
} else {
// 激活成功
// 修改用户的状态
existUser.setState(1);
existUser.setCode(null);
userService.update(existUser);
this.addActionMessage("激活成功:请去登录!");
}
return "msg";
}
~~~
Service：
~~~
// 业务层完成用户注册代码:
public void save(User user) {
// 将数据存入到数据库
user.setState(0); // 0:代表用户未激活. 1:代表用户已经激活.
String code = UUIDUtils.getUUID()+UUIDUtils.getUUID();//调用随机ID生成工具
user.setCode(code);
userDao.save(user);
// 发送激活邮件;
MailUitls.sendMail(user.getEmail(), code);
}
// 业务层根据激活码查询用户
public User findByCode(String code) {
return userDao.findByCode(code);
}
// 修改用户的状态的方法
public void update(User existUser) {
userDao.update(existUser);
}
~~~
Dao:
~~~
public void save(User user) {
// TODO Auto-generated method stub
this.getHibernateTemplate().save(user);
}
// 根据激活码查询用户
public User findByCode(String code) {
String hql = "from User where code = ?";
List<User> list = this.getHibernateTemplate().find(hql,code);
if(list != null && list.size() > 0){
return list.get(0);
}
return null;
}
// 修改用户状态的方法
public void update(User existUser) {
this.getHibernateTemplate().update(existUser);
}
~~~
注册成功后激活之前数据库截图
激活之后数据库截图
因为我们只希望用户激活一次，所以激活成功后将数据的code字段清空，state改为1。目前系统没有上线，为了方便测试，我用的本地邮箱测试，仅支持局域网，需要外网的请参见博客[http://blog.csdn.net/huyuyang6688/article/details/48031347](http://http//blog.csdn.net/huyuyang6688/article/details/48031347)，以上内容有不足之处请大家批评指正，谢谢！
Tomcat+Servlet登录页面实例
最后更新于：2022-04-01 07:14:12
# Tomcat+Servlet登录页面实例
## 概念
Tomcat 服务器是一个免费的开放源代码的Web 应用服务器，属于轻量级应用服务器，在中小型系统和并发访问用户不是很多的场合下被普遍使用，是开发和调试JSP 程序的首选。对于一个初学者来说，可以这样认为，当在一台机器上配置好Apache 服务器，可利用它响应HTML（标准通用标记语言下的一个应用）页面的访问请求。实际上Tomcat 部分是Apache 服务器的扩展，但它是独立运行的，所以当你运行tomcat 时，它实际上作为一个与Apache 独立的进程单独运行的。
Servlet 是在服务器上运行的小程序。服务器上需要一些程序，常常是根据用户输入访问数据库的程序。这些通常是使用公共网关接口（Common Gateway Interface，CGI）应用程序完成的。然而，在服务器上运行 Java，这种程序可使用 Java 编程语言实现。在通信量大的服务器上，JavaServlet 的优点在于它们的执行速度更快于 CGI 程序。各个用户请求被激活成单个程序中的一个线程，而无需创建单独的进程，这意味着服务器端处理请求的系统开销将明显降低。
## 技术前提
首先要下载好Tomcat和jdk,并配置好相应的系统变量，详情查看[http://blog.csdn.net/wangyy130/article/details/47166695](http://blog.csdn.net/wangyy130/article/details/47166695)，然后在这个小例子中，还需要将Tomcat 中的servlet包的安装路径添加到用户变量中，添加方法跟添加系统变量类似，在用户变量中添加一个classpath，变量值就是你安装的Tomcat中servlet包的路径。然后要在Tomcat 中搭好一个小的系统框架，由于Tomcat版本可能不同，相关技术百度就可以。
## 实例
### Servlet实现顺序图
###代码
~~~
<html>
<head>
<title>登录</title>
</head>
<body>
<form action="loginServlet">
用户：<input type="text" name="username"><br>
密码：<input type="password" name="password"><br>
<input type="submit" value="登录">
</form>
</body>
</html>
~~~
~~~
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class LoginServlet extends HttpServlet{
protected void doGet(HttpServletRequest request,HttpServletResponse response)throws ServletException,IOException{
String username=request.getParameter("username");
String password=request.getParameter("password");
System.out.println("username=" + username);
System.out.println("password=" + password);
response.setContentType("text/html");
response.getWriter().println("Login Sucess!!!");
}
}
~~~
~~~
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
version="3.0"
metadata-complete="true">
<servlet>
<servlet-name>MyServlet</servlet-name>
<servlet-class>LoginServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>MyServlet</servlet-name>
<url-pattern>/loginServlet</url-pattern>
</servlet-mapping>
</web-app>
~~~
### 界面
### 运行结果
例子很简单，有配置变量问题或者Tomcat搭建问题的可以私下联系我，左上角联系方式。有不足之处请大家批评指正！
爸爸和儿子的故事带你理解java线程
最后更新于：2022-04-01 07:14:10
# 爸爸和儿子的故事带你理解java线程
今天回顾线程方面的知识，发现一个很有意思的小程序，是用来说明多线程的下面贴出来分享下，对初学者理解线程有很大的帮助
爸爸和儿子的故事
~~~
public class FatherThread extends Thread{
@Override
public void run() {
System.out.println("爸爸想抽烟，发现烟抽完了");
System.out.println("爸爸让儿子去买包红塔山");
Thread son = new SonThread();
son.start();
System.out.println("爸爸等儿子买烟回来");
try {
//join含义：等待son线程执行完毕，father线程才继续执行
son.join();
}
catch (InterruptedException e) {
System.out.println("爸爸出门去找儿子跑哪去了");
System.exit(1);
}
System.out.println("爸爸高兴的接过烟开始抽，并把零钱给了儿子");
}
}
~~~
~~~
public class SonThread extends Thread{
@Override
public void run() {
String tags ="\t\t\t\t\t";
System.out.println(tags+"儿子去买烟了");
System.out.println(tags+"儿子去买烟要10分钟");
try {
for(int i =0; i<10;){
Thread.sleep(1000);
System.out.println(tags+"儿子出去第"+ ++i +"分钟");
}
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println(tags+"儿子去买烟回来了");
}
}
~~~
~~~
public class Main {
public static void main(String[] args){
System.out.println("爸爸和儿子的故事");
Thread faThread =new FatherThread();
faThread.start();
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
~~~
运行结果
爸爸和儿子的故事
爸爸想抽烟，发现烟抽完了
爸爸让儿子去买包红塔山
爸爸等儿子买烟回来
儿子去买烟了
儿子去买烟要10分钟
儿子出去第1分钟
儿子出去第2分钟
儿子出去第3分钟
儿子出去第4分钟
儿子出去第5分钟
儿子出去第6分钟
儿子出去第7分钟
儿子出去第8分钟
儿子出去第9分钟
儿子出去第10分钟
儿子去买烟回来了
爸爸高兴的接过烟开始抽，并把零钱给了儿子
程序进入主函数，首先father线程开始执行。爸爸让儿子去买烟，然后等待儿子买烟回来，这时son线程启动10分钟后儿子回来fathrer线程继续执行。
Java系列之EJB
最后更新于：2022-04-01 07:14:07
# Java系列之EJB
## 简介
EJB是sun的JavaEE服务器端组件模型，设计目标与核心应用是部署分布式应用程序。凭借java跨平台的优势，用EJB技术部署的分布式系统可以不限于特定的平台。EJB (Enterprise JavaBean)是J2EE(javaEE)的一部分，定义了一个用于开发基于组件的企业多重应用程序的标准。其特点包括网络服务支持和核心开发工具(SDK)。 在J2EE里，Enterprise Java Beans（EJB）称为Java 企业Bean，是Java的核心代码，分别是会话Bean（Session Bean），实体Bean（Entity Bean）和消息驱动Bean（MessageDriven Bean）。
##会话Bean
SessionBean用于实现业务逻辑，它可以是有状态的，也可以是无状态的。每当客户端请求时，容器就会选择一个SessionBean来为客户端服务。Session Bean可以直接访问数据库，但更多时候，它会通过Entity Bean实现数据访问。
## 实体Bean
Entity Bean是域模型对象，用于实现O/R映射，负责将数据库中的表记录映射为内存中的Entity对象，事实上，创建一个Entity Bean对象相当于新建一条记录，删除一个Entity Bean会同时从数据库中删除对应记录，修改一个Entity Bean时，容器会自动将Entity Bean的状态和数据库同步。
## 消息驱动Bean
是EJB2.0中引入的新的企业Bean，它基于JMS消息，只能接收客户端发送的JMS消息然后处理。MDB实际上是一个异步的无状态SessionBean，客户端调用MDB后无需等待，立刻返回，MDB将异步处理客户请求。这适合于需要异步处理请求的场合，比如订单处理，这样就能避免客户端长时间的等待一个方法调用直到返回结果。
EJB实际上是SUN的J2EE中的一套规范,并且规定了一系列的API用来实现把EJB概念转换成EJB产品。EJB是BEANS，BEANS是什么概念？那就是得有一个容纳她，让她可劲造腾的地方,就是得有容器。EJB必须生存在EJB容器中，这个容器可是功能强大之极!她首先要包装你BEAN,。EJB的客户程序实际上从来就不和你编写的EJB直接打交道，他们之间是通过HOME/REMOTE接口来发生关系的。它负责你的BEAN的所有的吃喝拉撒睡,比如BEAN的持续化,安全性,事务管理。
个人对于EJB也不是很理解，只是做一些知识点的梳理，后面加深理解后再跟大家分享经验……
Java系列之XML
最后更新于：2022-04-01 07:14:05
# Java系列之XML
XML是一种可扩展标记语言，之前学习HTML的时候就已经学习过了，为什么今天要在这里重新提起呢？因为XML是J2EE的十三个规范之一。
## 重新回顾
可扩展标记语言，标准通用标记语言的子集，是一种用于标记电子文件使其具有结构性的标记语言。
在电子计算机中，标记指计算机所能理解的信息符号，通过此种标记，计算机之间可以处理包含各种的信息比如文章等。它可以用来标记数据、定义数据类型，是一种允许用户对自己的标记语言进行定义的源语言。 它非常适合万维网传输，提供统一的方法来描述和交换独立于应用程序或供应商的结构化数据。是Internet环境中跨平台的、依赖于内容的技术，也是当今处理分布式结构信息的有效工具。早在1998年，W3C就发布了XML1.0规范，使用它来简化Internet的文档信息传输。
## 加深理解
### 一、什么是可扩展标记语言？
可扩展标记语言是一种很像超文本标记语言的标记语言。
它的设计宗旨是传输数据，而不是显示数据。
它的标签没有被预定义。您需要自行定义标签。
它被设计为具有自我描述性。
它是W3C的推荐标准。
### 二、可扩展标记语言和超文本标记语言之间的差异
它不是超文本标记语言的替代。
它是对超文本标记语言的补充。
#### 它和超文本标记语言为不同的目的而设计：
它被设计用来传输和存储数据，其焦点是数据的内容。
超文本标记语言被设计用来显示数据，其焦点是数据的外观。
超文本标记语言旨在显示信息，而它旨在传输信息。
#### 对它最好的描述是：
它是独立于软件和硬件的信息传输工具。
## 两种解析方式
XML基本的解析方式有两种,一种叫SAX，另一种叫DOM。SAX是基于事件流的解析,DOM是基于XML文档树结构的解析.假设我们XML的内容和结构如下:
~~~
<?xml version="1.0" encoding="UTF-8"?>
<employees>
<employee>
<name>ddviplinux</name>
<sex>m</sex>
<age>30</age>
</employee>
</employees>
~~~
### 1.DOM生成和解析XML文档
为 XML 文档的已解析版本定义了一组接口。解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。优点：整个文档树在内存中，便于操作；支持删除、修改、重新排列等多种功能；缺点：将整个文档调入内存（包括无用的节点），浪费时间和空间；使用场合：一旦解析了文档还需多次访问这些数据；硬件资源充足（内存、CPU）。
~~~
public void parserXml(String fileName) {
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document document = db.parse(fileName);
NodeList employees = document.getChildNodes();
for (int i = 0; i < employees.getLength(); i++) {
Node employee = employees.item(i);
NodeList employeeInfo = employee.getChildNodes();
for (int j = 0; j < employeeInfo.getLength(); j++) {
Node node = employeeInfo.item(j);
NodeList employeeMeta = node.getChildNodes();
for (int k = 0; k < employeeMeta.getLength(); k++) { System.out.println(employeeMeta.item(k).getNodeName() + ":" + employeeMeta.item(k).getTextContent());
}
}
}
System.out.println("解析完毕");
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
~~~
### 2.SAX生成和解析XML文档
为解决DOM的问题，出现了SAX。SAX ，事件驱动。当解析器发现元素开始、元素结束、文本、文档的开始或结束等时，发送事件，程序员编写响应这些事件的代码，保存数据。优点：不用事先调入整个文档，占用资源少；SAX解析器代码比DOM解析器代码小，适于Applet，下载。缺点：不是持久的；事件过后，若没保存数据，那么数据就丢了；无状态性；从事件中只能得到文本，但不知该文本属于哪个元素；使用场合：Applet;只需XML文档的少量内容，很少回头访问；机器内存少；
~~~
public void parserXml(String fileName) {
SAXParserFactory saxfac = SAXParserFactory.newInstance();
try {
SAXParser saxparser = saxfac.newSAXParser();
InputStream is = new FileInputStream(fileName);
saxparser.parse(is, new MySAXHandler());
} catch (Exception e) {
e.printStackTrace();
}
}
~~~
Java系列之JNDI
最后更新于：2022-04-01 07:14:03
# Java系列之JNDI
## 简介
JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口，JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI服务供应接口(SPI)的实现，由管理者将JNDI API映射为特定的命名服务和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是命名服务的一种自然扩展。两者之间的关键差别是目录服务中对象不但可以有名称还可以有属性（例如，用户有email地址），而命名服务中对象没有属性。
### 命名服务
命名服务是一种服务，它提供了为给定的数据集创建一个标准名字的能力。它允许把名称同Java对象或资源关联起来，而不必指出对象或资源的物理ID。这类似于字典结构（或者是Java的map结构），该结构中键映射到值。例如在Internet上的域名服务（domain naming service，DNS）就是提供将域名映射到IP地址的命名服务，在打开网站时一般都是在浏览器中输入名字，通过DNS找到相应的IP地址，然后打开。
所有的因特网通信都使用TCP、UDP或IP协议。IP地址由4个字节32位二进制数字组成，数字和名字相比，对于人来说名字比数字要容易记忆，但对于计算机来讲，它更善于处理数字。
其实所有的命名服务都提供DNS这种基本功能，即一个系统向命名服务注册，命名服务提供一个值到另一个值的映射。然后，另外一个系统访问命名服务就可以取得映射信息。这种交互关系对分布式企业级应用来讲显得非常重要，在Java中，基本的名字操作包含在Context接口中。
### 目录服务
目录服务是一种特殊类型的数据库，与SQL Server、Access、Oracle等关系数据库管理系统相反，构造目录服务的目的是为了处理基于行为的事务，并且使用一种关系信息模型。目录服务将命名服务的概念进一步引申为提供具有层次结构的信息库，这一信息库除了包含一对一的关系外，还有信息的层次结构。对目录服务而言，这种层次结构通常用于优化搜索操作，并且也可以按实际情况进行分布或者跨网络复制。
一个目录服务通常拥有一个名字服务（但是一个名字服务不必具有一个目录服务）。如电话簿就是一个典型的目录服务，一般先在电话簿里找到相关的人名，再找到这个人的电话号码。
每一种目录服务都可以存储有关用户名、用户密码、用户组（如有关访问控制的 信息）、以太网地址、IP地址等信息。它所支持的信息和操作会因为所使用的目录服务的不同而不同。遗憾的是，访问不同目录服务的协议也会不同，所以读者需要了解多种API。
这就是JNDI的起源，就像JDBC一样，JNDI充当不同名称和目录服务的通用API或者说是前端，然后使用不同的后端适配器来连接实际服务。
JNDI是J2EE技术中的一个完整的组件。它支持通过一个单一的方法访问不同的、新的和已经存在的服务的方法。这种支持允许任何服务提供商执行通过标准服务提供商接口（SPI）协定插入JNDI框架。
## 作用
JNDI的功能简单说就是可以简单的方式去查找某种资源。 JNDI是一个应用程序设计的API，为开发人员提供了查找和访问各种命名和目录服务的通用、统一的接口，类似JDBC都是构建在抽象层。比如在Tomcat中配置了一个JNDI数据源，那么在程序中之需要用Java标准的API就可以查找到这个数据源，以后数据源配置发生变化了，等等，程序都不需要改动，之需要改改JNDI的配置就行。增加了程序的灵活性，也给系统解耦了。
## 总结
J2EE 规范要求所有 J2EE 容器都要提供 JNDI 规范的实现。JNDI 在 J2EE 中的角色就是“交换机” —— J2EE 组件在运行时间接地查找其他组件、资源或服务的通用机制。在多数情况下，提供 JNDI 供应者的容器可以充当有限的数据存储，这样管理员就可以设置应用程序的执行属性，并让其他应用程序引用这些属性（Java 管理扩展（Java Management Extensions，JMX）也可以用作这个目的）。JNDI 在 J2EE 应用程序中的主要角色就是提供间接层，这样组件就可以发现所需要的资源，而不用了解这些间接性。
在 J2EE 中，JNDI 是把 J2EE 应用程序合在一起的粘合剂，JNDI 提供的间接寻址允许跨企业交付可伸缩的、功能强大且很灵活的应用程序。这是 J2EE 的承诺，而且经过一些计划和预先考虑，这个承诺是完全可以实现的。
Java系列之JDBC和ODBC之间的区别与联系
最后更新于：2022-04-01 07:14:00
# Java系列之JDBC和ODBC之间的区别与联系
## JDBC简介
JDBC（Java Data Base Connectivity,java数据库连接）是一种用于执行SQL语句的Java API，它是Java十三个规范之一。可以为多种关系数据库提供统一访问，它由一组用Java语言编写的类和接口组成。JDBC提供了一种基准，据此可以构建更高级的工具和接口，使数据库开发人员能够编写数据库应用程序，同时，JDBC也是个商标名。
## ODBC简介
开放数据库互连（Open Database Connectivity，ODBC）是微软公司开放服务结构（WOSA，Windows Open Services Architecture）中有关数据库的一个组成部分，它建立了一组规范，并提供了一组对数据库访问的标准API（应用程序编程接口）。这些API利用SQL来完成其大部分任务。ODBC本身也提供了对SQL语言的支持，用户可以直接将SQL语句送给ODBC。开放数据库互连（ODBC）是Microsoft提出的数据库访问接口标准。开放数据库互连定义了访问数据库API的一个规范，这些API独立于不同厂商的DBMS，也独立于具体的编程语言（但是Microsoft的ODBC文档是用C语言描述的，许多实际的ODBC驱动程序也是用C语言写的。）ODBC规范后来被X/OPEN和ISO/IEC采纳，作为SQL标准的一部分，具体内容可以参看《ISO/IEC 9075-3:1995 (E) Call-Level Interface (SQL/CLI)》等相关的标准文件。
## 两者之间的联系
JDBC和ODBC都是用来连接数据库的启动程序，JDBC和ODBC由于具有数据库独立性甚至平台无关性，因而对Internet上异构数据库的访问提供了很好的支持。
两者之间的区别
### 1.JDBC比ODBC更容易理解
从事编程工作的朋友都知道Java比C语言更好学，主要是因为Java语言是面向对象的更接近人的思维认识，更容易被人接受。而C语言就较为抽象，跟人的认识思维相差较大，其开发出来的产品也具有类似特点。在ODBC中一个的简单的查询，也需求分为好几块内容;而在ODBC驱动程序内部再去整合，做一些复杂的操作。这不仅降低了数据库启动程序的性能，而且也给程序开发者开发实际运用程序带来了确定的负面效果。而JDBC数据库启动程序在设计的时间就包含了大部份基本数据操作功能，为此在编写一些常规的数据库操作语句时，如查询、更新等等，其所需求的源代码比 ODBC要少的多。故从这方面来说，JDBC数据库启动程序要比ODBC简易理解。
### 2.JDBC数据库驱动程序是面向对象的
JDBC完全遵循Java语言的优良特性。通常情况下，只要有Java功能需设计基础的用户都能在最短时间内了解JDBC驱动程序的架构，较量简易上手，能轻而易举的开发出强悍的数据库实际运用程序。而ODBC的话，由于其内部功能复杂，源代码编写要求高。为此即使是一个的C语言的高手，仍然需求花费不少的时间去了解那个数据库启动程序;在编写源代码的时间，还离不开有关的参考书本。
### 3.JDBC的移植性要比ODBC要好。
通常情况下，安装完ODBC驱动程序之后，还需求经过确定的配置才能够应用。而不相同的配置在不相同数据库服务器之间不能够通用。也那是说，装一次需求配置一次。但是JDBC数据库驱动程序则不相同。假如采用JDBC数据库驱动程序的话，则只需要选取适当的 JDBC数据库驱动程序，就不需要额外的配置。在安装过程中，JDBC数据库驱动程序会自己完成有关的配置。为此JDBC的移植性要比ODBC要好。
## 从ODBC向JDBC过度
也许数据库编程以前采用的是ODBC驱动程序，而假如数据库编程目前需要采用JDBC驱动程序，那么能否出现顺利过渡呢?答案是肯定的。在JDBC驱动程序中有一类叫作JDBC-ODBC桥接启动程序。这种类别的JDBC数据库驱动程序其底层是经过ODBC驱动程序来连接数据库的。假如原先的实际运用程序是基于ODBC数据库驱动程序的，或者数据库没有帮助对应的JDBC驱动程序，则数据库编程能利用JDBC-ODBC桥接驱动程序来实现。也那是说，桥接驱动程序能利用现有的ODBC驱动程序来存取联系型数据库。为此者不仅能保留先前的开发架构(经过ODBC来存取数据)，还能立即应用Java作为新的开发环境，从而出现ODBC数据库驱动程序到JDBC的顺利转型。
不过在采用这种桥接驱动程序的时间，需求留意几个难点。一是那个桥接驱动程序仍然需要用到ODBC数据库驱动程序。由于桥接驱动程序直接联系的对象是ODBC驱动程序，然后再经过ODBC驱动程序去访问数据库。为此在客户端必需先安装并配置好ODBC驱动程序。假如采用的是三层式的开发框架，也需求安装ODBC驱动程序。其次，在这种模式下，实际运用程序先调用JDBC，然后再经过JDBC调用ODBC，最后再跟数据库通信。显然其中间多了几个环节。由于其中间环节较量多，但数据访问出现难点的时候，就不太好查难点。这就好像一道水管，假如中间的接口多了的话，则除了漏水的几率就较量高。假如真的除了漏水的话，则查询漏水点的时间也会较量困难。为此笔者以为，采用桥接类别的JDBC驱动程序只是权宜之计。在适当的时间，数据库开发还是需要调整原先的开发架构，全部都转到JDBC驱动程序上来。桥接程序只是为数据库开发争取确定的时间。虽然那个转型过程中的阵痛是较痛的，但确是不可避免的。长痛不如短痛，笔者意见数据库开发还是及早停止过渡为好。并在估计的情况下，把以前的开发架构也停止调整，以采用真正意义上的JDBC驱动程序。
JDBC虽然在一定程度上比ODBC操作简单，容易理解。但是世间万物存在即有道理，并不是说JDBC好就所有的情况下都能使用JDBC，两者之间没有好坏之分，只是在特定的情况下能够选取合适的实现方式即可。参考文章[http://blog.sina.com.cn/s/blog_4cf8aad30100lx47.html](http://http//blog.sina.com.cn/s/blog_4cf8aad30100lx47.html)（貌似博主是翻译过来的，好多字词用得不太合适，理解起来有些困难，本人结合自己的认识做了替换）个人的一点点认识和整理，有不足之处请大家批评指正。
前言
最后更新于：2022-04-01 07:13:58
> 原文出处：[java](http://blog.csdn.net/column/details/u010926964java.html)
作者：[邵鸿鑫](http://blog.csdn.net/u010926964)
**本系列文章经作者授权在看云整理发布，未经作者允许，请勿转载！**
# Java
> 从java十三个标准开始到ssh三大框架的学习和总结，希望对大家有所帮助。