JNDI连接数据库-阿里云开发者社区

一、JNDI数据库连接通用数据访问层（JNDIDBManager）

代码下：

package com.myphome.dao;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;

/**
* JNDI数据库连接通用数据访问层
* */
public class JNDIDBManager {
//mySql连接固定参数和数据源名称字符串(分为两部分"java：comp/env"为JavaEE默认路径,"jdbc/blog"为DataSource名)
private static final String MYSQL_DATASOURCE_STRING="java:comp/env/jdbc/blog";
//sqlserver连接固定参数和数据源名称字符串
private static final String SQLSERVER_DATASOURCE_STRING="java:comp/env/googlesnack";
//oracle连接固定参数和数据源名称字符串
private static final String ORACLE_DATASOURCE_STRING="java:comp/env/users";

//使用单例模式来保存数据库对象
private static ThreadLocal<Connection> tlconn=new ThreadLocal<Connection>();
/**
* 获取JNDI连接数据库对象
* @throws NamingException
* @throws SQLException
* */
public Connection getConnection() throws NamingException, SQLException{
/*
* ThreadLocal类可以保存一个对象，只能保存一个，调用get方法得到保存的对象, 调用set方法向ThreadLocal中保存对象
* 调用remove()方法，将ThreadLocal中的对象移除
* 如果ThreadLocal中保存了连接对象，就从ThreadLocal中获取连接对象
* 如果ThreadLocal没有保存连接对象，就从连接池中获取一个连接对象，并把该连接对象保存到ThreadLocal中
*/
  //从ThreadLocal获取Connection对象
  Connection conn=tlconn.get();
  //如果ThreadLocal中存在连接对象，则返回连接对象
  if(conn!=null){
   return conn;
  }else{
  //否则从连接池中获取一个连接对象，然后将连接对象放到ThreadLocal中，并返回该连接对象
   //数据源DataSource由Tomcat提供，不能在程序中创建实例,并使用JNDI获得DataSource引用
   /*
    *JNDI（Java Naming and Directory Interface，Java命名和目录接口）是一组在Java应用中访问命名和目录服务的API
    *javax.namming.Context接口的lookup()方法
    */
   Context context=new InitialContext();
   /*
    *javax.sql.DataSource接口负责建立与数据库的连接
    *从Tomcat的数据源获得连接
    *把连接保存在连接池中
    */
   //mysql
   DataSource ds=(DataSource) context.lookup(MYSQL_DATASOURCE_STRING);
   //sqlserver
//   DataSource ds=(DataSource) context.lookup(SQLSERVER_DATASOURCE_STRING);
//   //oracle
//   DataSource ds=(DataSource) context.lookup(ORACLE_DATASOURCE_STRING);
   //获取连接对象
   conn=ds.getConnection();
   //将数据库连接对象放入到ThreadLocal中
   tlconn.set(conn);
   return conn;
  }
}
/**
* 从ThreadLocal中移除连接对象，以免线程池误操作本地变量
* */
public void removeConnection()throws Exception {
  tlconn.remove();//将ThreadLocal中保存的连接对象移除，移除后tl.get()方法得到的结果是null
}
/**
* 为sql语句占位符赋值
* */
private void operateParameters(PreparedStatement pstmt,Object ... args) throws SQLException {
    if (args != null && args.length > 0) {
       for (int i = 0; i < args.length; i++) {
            pstmt.setObject(i + 1, args[i]);
       }
   }
}
/**
* 将结果集转换为实体对象的接口
* Mapper接口用于规定将数据行转换为entity的方法，以Mapper结尾的类(如：ArticleMapper)是该接口的子类
* Mapper子类用于将rs指向的数据行转换为指定的entity对象
* */
public static interface RowMapper<T> {
  public T rowMapper(ResultSet rs);
}
/**
* 数据库查询方法
* @return list<T>
* 第二个参数rowmapper：明确由哪个类负责将数据行转换为entity对象
* 第一个参数：sql语句
* 第三个参数：sql语句参数的值
* */
public <T> List<T> executeQuery(String sql, RowMapper mapper,Object ... values) throws Exception{
  List list = new ArrayList<T>();
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
   conn = getConnection();
   pstmt = conn.prepareStatement(sql);
   operateParameters(pstmt, values);
   rs = pstmt.executeQuery();

   //将结果集一条记录转换为实体对象，并添加到集合中
   while (rs.next()) {
    T obj = (T) mapper.rowMapper(rs);
    list.add(obj);
   }
  } catch (SQLException e) {
   e.printStackTrace();
   throw new Exception("执行数据查询时，失败");
  } finally {
   //关闭rs
   closeResultSet(rs);
   //关闭pstmt
   closeStatement(pstmt);
   //注意，rs和pstmt是DBManager关闭的，conn是有调用DBManager类关闭的
  }
  return list;
}
/**
* 数据库更新数据方法（添加、修改、删除）
* @return int
* */
public int executeUpdate(String sql, Object...args) throws Exception {
  PreparedStatement pstmt = null;
  int rowCount = 0;
  Connection conn = getConnection();
  try {
   pstmt = conn.prepareStatement(sql);
   operateParameters(pstmt, args);
   rowCount = pstmt.executeUpdate();
  } catch (SQLException e) {
   e.printStackTrace();
   throw new Exception("更新数据失败");
  } finally {
   closeStatement(pstmt);
  }
  return rowCount;
}
/**
* 执行聚合函数查询(求总和)
* */
public int executeScalar(String sql,Object ...values){
  Connection conn = null;
  PreparedStatement pstmt = null;
  ResultSet rs = null;
  try {
   conn = getConnection();
   pstmt = conn.prepareStatement(sql);
   operateParameters(pstmt, values);
   rs = pstmt.executeQuery();
   if(rs.next()){
    return rs.getInt(1);
   }
   return 0;
  }catch (Exception e) {
   return 0;
  }finally{
   closeResultSet(rs);
   closeStatement(pstmt);
  }
}
/**
* 关闭连接
*
* @param dbConnection
*            Connection
*/
public void closeConnection() {
  try {
   Connection conn = tlconn.get();
   if (conn != null && (!conn.isClosed())) {
    //关闭连接对象
    conn.close();
    conn = null;
    //将连接对象从tl中移除
    tlconn.remove();
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }

}
/**
* 关闭结果集
*/
public void closeResultSet(ResultSet rs) {
  try {
   if (rs != null) {
    rs.close();
    rs = null;
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }
}

/**
* 关闭语句
*/
public void closeStatement(PreparedStatement pstmt) {
  try {
   if (pstmt != null) {
    pstmt.close();
    pstmt = null;
   }
  } catch (SQLException e) {
   e.printStackTrace();
  }
}
/**
* 开始事务
* */
public void setAutoCommit()throws Exception {
  try {
   getConnection();

   //开始事务
   tlconn.get().setAutoCommit(false);
  } catch (SQLException e) {
   e.printStackTrace();
   throw new Exception("开始事务时，出现错误");
  }
}
/**
* 提交事务
* */
public void commit() throws Exception {
  try {
   //提交事务
   tlconn.get().commit();
  } catch (SQLException e) {
   e.printStackTrace();
   throw new Exception("事务提交失败");
  }
}
/**
* 回滚事务
* */
public void rollback() throws Exception{
  try {
   //回滚事务
   tlconn.get().rollback();
  } catch (SQLException e) {
   e.printStackTrace();
   throw new Exception("事务回滚失败");
  }
}
}

二、将结果集rs指向的数据当前一行记录转换为指定的entity对象的mapper类（如：FoodMapper）

package com.myphome.mapper;
import java.sql.ResultSet;

import com.myphome.dao.JNDIDBManager;
import com.myphome.entity.Food;
/**
*FoodMapper用于将界面需要的数据查询出来，然后将rs指向的一条记录转换为Food实体类
*/
public class FoodMapper implements JNDIDBManager.RowMapper<Food> {

public Food rowMapper(ResultSet rs) {
  Food food = null;
  try {
   food = new Food();
   food.setAgio(rs.getDouble("agio"));
   food.setCharacteristics(rs.getString("characteristics"));
   food.setCuisine(null);//把其他实体类作为此对象属性赋值（用第二个sql查询赋值，即sql嵌套）
   food.setCuisineId(rs.getInt("cuisineId"));
   food.setEatery(null);
   food.setEateryId(rs.getInt("eateryId"));
   food.setFingredient(rs.getString("fingredient"));
   food.setId(rs.getInt("id"));
   food.setImg(rs.getString("img"));
   food.setIntegral(rs.getInt("integral"));
   food.setName(rs.getString("name"));
   food.setPrice(rs.getDouble("price"));
   food.setRemark(rs.getString("remark"));
  } catch (Exception e) {
   food =null;
   e.printStackTrace();
  }
  return food;
}
}
三、Food实体类

package com.myphome.entity;

import java.io.Serializable;

/**
* 菜品
*/
public class Food implements Serializable{
private int id; //食物的主键
private String name;//食物的名称
private String fingredient;//食物的配料
private double price;//食物的价格
private double agio;//食物的折扣
private String remark;//食物的简介
private String characteristics;//食物的特色
private String img;//食物的图片
private int integral;//购买食物所送积分

private int cuisineId;//食物所属菜系的id
private int eateryId;//食物所属餐馆的id

//对象属性，菜系类
private Cuisine cuisine;
//对象属性，菜馆类
private Eatery eatery;
public int getId() {
  return id;
}
public void setId(int id) {
  this.id = id;
}
public String getName() {
  return name;
}
public void setName(String name) {
  this.name = name;
}
/**
* 获取配料
* */
public String getFingredient() {
  return fingredient;
}

/**
* 设置配料
* */
public void setFingredient(String fingredient) {
  this.fingredient = fingredient;
}
public double getPrice() {
  return price;
}
public void setPrice(double price) {
  this.price = price;
}
public double getAgio() {
  return agio;
}
public void setAgio(double agio) {
  this.agio = agio;
}
public String getRemark() {
  return remark;
}
public void setRemark(String remark) {
  this.remark = remark;
}
/**
* 获取特色
* */
public String getCharacteristics() {
  return characteristics;
}
/**
* 设置特色
* */
public void setCharacteristics(String characteristics) {
  this.characteristics = characteristics;
}
public String getImg() {
  return img;
}
public void setImg(String img) {
  this.img = img;
}
/**
* 获取积分
* */
public int getIntegral() {
  return integral;
}

/**
* 设置积分
* */
public void setIntegral(int integral) {
  this.integral = integral;
}
public int getCuisineId() {
  return cuisineId;
}
public void setCuisineId(int cuisineId) {
  this.cuisineId = cuisineId;
}
public int getEateryId() {
  return eateryId;
}
public void setEateryId(int eateryId) {
  this.eateryId = eateryId;
}
public Cuisine getCuisine() {
  return cuisine;
}
public void setCuisine(Cuisine cuisine) {
  this.cuisine = cuisine;
}
public Eatery getEatery() {
  return eatery;
}
public void setEatery(Eatery eatery) {
  this.eatery = eatery;
}
}
四、JNDI的配置步骤：

1.Tomcat的conf/context.xml中的配置：

注：

2.加入数据库驱动文件：

把数据库驱动的.jar文件，加入到Tomcat下的lib中。

3.（可省略）应用程序的 web.xml 文件的配置，在web.xml中配置<resource-ref>：

注：如果用junit测试，将报错：

javax.naming.NoInitialContextException: Need to specify class name in environment or system property, or as an applet parameter, or in an application resource file: java.naming.factory.initial

解决:用web项目形式测试，则成功！

//tomcat下context.xml 中有汉字将报编码错误。

//界面提交using POST method，则：this.dopost（request，response）;

JNDI连接数据库

热门文章

最新文章

相关课程

相关电子书

相关实验场景