jboss中连接池的相关配置

一、中间件配置
主要配置在JBOSS服务器的server/default/deploy目录下oracle-ds.xml文件。主要参数说明：

local-tx-datasource:本地数据源配置根标记名；
jndi-name:数据源JNDI名称，对应Application.properties文件中配置；
driver-class:数据库连接驱动类；
connection-url:数据库连接URL字符串；
user-name:数据库连接用户名；
password:数据库连接密码；
min-pool-size:连接池可激活最小连接数；
max-pool-size:连接池可激活最大连接数；
blocking-timeout-millis:抛出异常前最大的等待连接时间，单位毫秒；
idle-timeout-minutes:连接池已激活的空闲连接超时时间，单位秒。
二、事务管理机制


EJB容器初始化数据持久化环境SessionContext;
用户调用某一xxxSessionBean中的事务方法；
xxxSessionBean调用某一业务逻辑xxxLogic操作；
xxxLogic调用DAO层存取数据；
当2～4过程中出现异常，sessionContext调用方法setRollbbackonly来捕捉异常，并且把该异常转化为EJBException(继承自RuntimeException)继续抛出，同时回滚事务。
三、事务管理配置
由JBOSS的EJB容器管理事务，一般是配置在JBOSS的server/default/conf目录下jboss-service.xml文件中。具体配置参数说明如下：
<mbean code="org.jboss.tm.TransactionManagerService"
name="jboss:service=TransactionManager"
xmbean-dd="resource:xmdesc/TransactionManagerService-xmbean.xml">
<!-- 容器管理事务超时时间，单位秒 -->
<attribute name="TransactionTimeout">300</attribute>
<!-- 容器管理事务的全局标示。值为true表示启用全局性事务，false表示不启用 -->
<attribute name="GlobalIdsEnabled">true</attribute>
<depends optional-attribute-name="XidFactory">jboss:service=XidFactory</depends>
</mbean>

四、JAVA代码获取数据库连接
[java] view plaincopyprint?
package com.sunrise.www.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.sunrise.www.utils.exception.DAOException;

public class DAOUtils {

private static final Log log = LogFactory.getLog(DAOUtils.class);
private static boolean datasource_flag = false;
private static boolean read_datasource_flag = true;
private static boolean read_direct_conn_flag = false;
private static String datasource_name = null;

public static Connection getDBConnection(String datasourceName)
throws DAOException {
try {
return ServiceLocator.getInstance().getDataSource(datasourceName).getConnection();
} catch (Exception ex) {
throw new DAOException("Cannot connect to database.", ex);
}
}

public static Connection getDBConnection() throws DAOException {
try {
if (read_datasource_flag) {
String tmp = SystemConfig.getDefaultConfig("USE_DATASOURCE").toLowerCase();
datasource_flag = Boolean.parseBoolean(tmp);
read_datasource_flag = false;
}

Connection conn = null;

if (!datasource_flag) {
String user = "", password = "", url = "", driver = "";
if (!read_direct_conn_flag) {
user = SystemConfig.getDefaultConfig("USER");
password = SystemConfig.getDefaultConfig("PASSWORD");
url = SystemConfig.getDefaultConfig("URL");
driver = SystemConfig.getDefaultConfig("DATABASEDRIVER");
read_direct_conn_flag = true;
}
Class.forName(driver).newInstance();
conn = DriverManager.getConnection(url, user, password);
conn.setAutoCommit(true);
} else {
if (datasource_name == null)
datasource_name = SystemConfig.getDefaultConfig("DATASOURCE_NAME");
conn = getDBConnection(datasource_name);
}
return conn;
} catch (Exception ex) {
log.error("连接数据库出错", ex);
throw new DAOException(ex);
}
}

public static void closeAll(Connection dbConnection,
PreparedStatement stmt, ResultSet result) throws DAOException {
close(result);
close(stmt);
close(dbConnection);
}

public static void close(Connection dbConnection, PreparedStatement stmt)
throws DAOException {
close(stmt);
close(dbConnection);
}

public static void close(Connection dbConnection) throws DAOException {
try {
if (dbConnection != null && !dbConnection.isClosed()) {
dbConnection.close();
dbConnection = null;
}
} catch (SQLException se) {
throw new DAOException("SQL Exception while closing " + "DB connection : /n", se);
}
}

public static void close(ResultSet result) throws DAOException {
try {
if (result != null) result.close();
} catch (SQLException se) {
throw new DAOException("SQL Exception while closing " + "Result Set : /n", se);
}
}

public static void close(PreparedStatement stmt) throws DAOException {
try {
if (stmt != null) stmt.close();
} catch (SQLException se) {
throw new DAOException("SQL Exception while closing " + "Statement : /n", se);
}
}

/**
* @return read_datasource_flag
*/
public static boolean isRead_datasource_flag() {
return read_datasource_flag;
}

/**
* @param read_datasource_flag
* 设置read_datasource_flag
*/
public static void setRead_datasource_flag(boolean read_datasource_flag) {
DAOUtils.read_datasource_flag = read_datasource_flag;
}

}



package com.sunrise.www.utils;

import java.util.Hashtable;

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

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

import com.sunrise.www.utils.exception.ServiceLocatorException;

public class ServiceLocator {
private static Log log = LogFactory.getLog(ServiceLocator.class);
private static ServiceLocator serviceLocator;
private static InitialContext context;
private static Hashtable<String, DataSource> datasourceTable = new Hashtable<String, DataSource>();

private ServiceLocator() throws ServiceLocatorException {
try {
context = getInitialContext();
} catch (Exception e) {
log.error(e.getMessage());
throw new ServiceLocatorException(e.getMessage());
}
}

/**
* 取得一个服务定位器的实例
* @return
* @throws ServiceLocatorException
*/
public static synchronized ServiceLocator getInstance()
throws ServiceLocatorException {
if (serviceLocator == null)
serviceLocator = new ServiceLocator();
return serviceLocator;
}

/**
* 取J2EE服务器的相关环境变量
* @return
* @throws NamingException
*/
public static InitialContext getInitialContext() throws NamingException {
return new InitialContext();
}

/**
* 取指定的 data source
* @param datasourceName
* @return
* @throws ServiceLocatorException
*/
public DataSource getDataSource(String datasourceName)
throws ServiceLocatorException {
try {
DataSource dataSource = (DataSource) datasourceTable.get(datasourceName);
if (dataSource == null) {
dataSource = (DataSource) context.lookup(actualJndiName(datasourceName));
if (dataSource == null) {
log.error("不能初始化系统对象: " + datasourceName);
throw new ServiceLocatorException("不能初始化系统对象: " + datasourceName);
}
datasourceTable.put(datasourceName, dataSource);
}
return dataSource;
} catch (NamingException ne) {
log.error(ne.getMessage());
throw new ServiceLocatorException(ne);
}
}

private String actualJndiName(String jndiName) throws NamingException {
String prefixes = (String) context.getEnvironment().get(InitialContext.URL_PKG_PREFIXES);
return ((prefixes != null && prefixes.contains("jboss")) ? "java:/" : "") + jndiName;
}
}



package com.sunrise.www.utils;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

import com.sunrise.www.utils.exception.SystemConfigException;

public class SystemConfig {
private static final String DEFAULT_CONFIG = "Application.properties";

private static ClassLoader defaultClassLoader;

private SystemConfig() {
}

/**
* Returns the default classloader (may be null).
*
* @return The default classloader
*/
public static ClassLoader getDefaultClassLoader() {
return defaultClassLoader;
}

/**
* Sets the default classloader
*
* @param defaultClassLoader -
* the new default ClassLoader
*/
public static void setDefaultClassLoader(ClassLoader defaultClassLoader) {
SystemConfig.defaultClassLoader = defaultClassLoader;
}

/**
* Returns a resource on the classpath as a Properties object
*
* @param resource
* The resource to find
* @return The resource
* @throws IOException
* If the resource cannot be found or read
*/
public static Properties getResourceAsProperties(String resource)
throws IOException {
Properties props = new Properties();
InputStream in = null;
String propfile = resource;
in = getResourceAsStream(propfile);
props.load(in);
in.close();
return props;
}

/**
* Returns a resource on the classpath as a Properties object
*
* @param loader
* The classloader used to load the resource
* @param resource
* The resource to find
* @return The resource
* @throws IOException
* If the resource cannot be found or read
*/
public static Properties getResourceAsProperties(ClassLoader loader,
String resource) throws IOException {
Properties props = new Properties();
InputStream in = null;
String propfile = resource;
in = getResourceAsStream(loader, propfile);
props.load(in);
in.close();
return props;
}

/**
* Returns a resource on the classpath as a Stream object
*
* @param resource
* The resource to find
* @return The resource
* @throws IOException
* If the resource cannot be found or read
*/
public static InputStream getResourceAsStream(String resource)
throws IOException {
return getResourceAsStream(getClassLoader(), resource);
}

/**
* Returns a resource on the classpath as a Stream object
*
* @param loader
* The classloader used to load the resource
* @param resource
* The resource to find
* @return The resource
* @throws IOException
* If the resource cannot be found or read
*/
public static InputStream getResourceAsStream(ClassLoader loader,
String resource) throws IOException {
InputStream in = null;
if (loader != null)
in = loader.getResourceAsStream(resource);
if (in == null)
in = ClassLoader.getSystemResourceAsStream(resource);
if (in == null)
throw new IOException("Could not find resource " + resource);
return in;
}

private static ClassLoader getClassLoader() {
if (defaultClassLoader != null) {
return defaultClassLoader;
} else {
return Thread.currentThread().getContextClassLoader();
}
}

// 本行以上代码拷贝自com.ibatis.common.resources.Resources

/**
* 从默认配置文件(Application.properties)中读取配置
*
* @param key
* 键
* @param defaultValue
* 默认值
* @return
*/
public static String getDefaultConfig(String key, String defaultValue) {
return loadProperties(DEFAULT_CONFIG).getProperty(key, defaultValue);
}

public static String getDefaultConfig(String key) {
return loadProperties(DEFAULT_CONFIG).getProperty(key);
}

public static String getConfig(String resource, String key) {
return loadProperties(resource).getProperty(key);
}

public static String getConfig(String resource, String key,
String defaultValue) {
return loadProperties(resource).getProperty(key);
}

public static Properties loadProperties(String resource) {
try {
Properties props = getResourceAsProperties(resource);
if(props != null){
return props;
}
throw new SystemConfigException("Resource " + resource + " is not exist.");
} catch (IOException e) {
throw new SystemConfigException(e);
}
}
}