我的问题如下。我需要一个类,该类作为Web系统中数据库连接的单点工作,以免让一个用户拥有两个打开的连接。我需要使其尽可能最佳,并且应该管理系统中的每个事务。换句话说,只有该类才能实例化DAO。为了使它更好,它还应该使用连接池!我该怎么办?
您将需要实现DAO管理器。我从这个网站获得了主要思想,但是我做了自己的实现,解决了一些问题。
首先,您必须配置一个连接池。连接池是一个连接池。当您的应用程序运行时,连接池将启动一定数量的连接,这样做是为了避免在运行时创建连接,因为这是一项昂贵的操作。本指南无意说明如何配置一个,因此请四处浏览。
作为记录,我将使用Java作为语言,并使用Glassfish作为服务器。
让我们从创建一个DAOManager
类开始。让我们为它提供在运行时打开和关闭连接的方法。没什么好看的。
public class DAOManager {
public DAOManager() throws Exception {
try
{
InitialContext ctx = new InitialContext();
this.src = (DataSource)ctx.lookup("jndi/MYSQL"); //The string should be the same name you're giving to your JNDI in Glassfish.
}
catch(Exception e) { throw e; }
}
public void open() throws SQLException {
try
{
if(this.con==null || !this.con.isOpen())
this.con = src.getConnection();
}
catch(SQLException e) { throw e; }
}
public void close() throws SQLException {
try
{
if(this.con!=null && this.con.isOpen())
this.con.close();
}
catch(SQLException e) { throw e; }
}
//Private
private DataSource src;
private Connection con;
}
这不是一个很特别的课程,但是它将成为我们要做的基础。因此,这样做:
DAOManager mngr = new DAOManager();
mngr.open();
mngr.close();
应该在一个对象中打开和关闭您与数据库的连接。
现在,如果我们这样做了?
DAOManager mngr1 = new DAOManager();
DAOManager mngr2 = new DAOManager();
mngr1.open();
mngr2.open();
有人可能会争辩说:“您为什么要这样做?” 。但是,您永远都不知道程序员会做什么。即使那样,程序员也可能在打开新连接之前先关闭连接。另外,这浪费了应用程序资源。如果您实际上希望拥有两个或多个打开的连接,请在此处停止,这将是每个用户一个连接的实现。
为了使它成为单点,我们将必须将此类转换为singleton。单例是一种设计模式,它允许我们只有一个给定对象的一个实例。因此,让我们将其设为单例!
public
构造函数转换为私有的。我们只能给调用它的人一个实例。在DAOManager
随后变成了工厂!private
类,该类实际上将存储一个单例。getInstance()
方法,该方法将为我们提供一个可以调用的单例实例。让我们看看它是如何实现的。
public class DAOManager {
public static DAOManager getInstance() {
return DAOManagerSingleton.INSTANCE;
}
public void open() throws SQLException {
try
{
if(this.con==null || !this.con.isOpen())
this.con = src.getConnection();
}
catch(SQLException e) { throw e; }
}
public void close() throws SQLException {
try
{
if(this.con!=null && this.con.isOpen())
this.con.close();
}
catch(SQLException e) { throw e; }
}
//Private
private DataSource src;
private Connection con;
private DAOManager() throws Exception {
try
{
InitialContext ctx = new InitialContext();
this.src = (DataSource)ctx.lookup("jndi/MYSQL");
}
catch(Exception e) { throw e; }
}
private static class DAOManagerSingleton {
public static final DAOManager INSTANCE;
static
{
DAOManager dm;
try
{
dm = new DAOManager();
}
catch(Exception e)
dm = null;
INSTANCE = dm;
}
}
}
当应用程序启动时,只要有人需要单例,系统就会实例化一个DAOManager
。非常整洁,我们已经创建了一个访问点!
但是单例是反模式,因为原因!我知道有些人不喜欢单例。但是,它相当不错地解决了这个问题(并且解决了我的问题)。这只是实现此解决方案的一种方式,如果您有其他建议,欢迎提出建议。
是的,确实有。单例只会为整个应用程序创建一个实例!这在许多级别上都是错误的,特别是如果我们有一个Web系统,其中我们的应用程序将是多线程的!那我们该如何解决呢?
Java提供了一个名为的类ThreadLocal
。一个ThreadLocal
线程每个线程有一个实例。嘿,它解决了我们的问题!要详细了解其工作原理,您需要了解其用途,以便我们继续。
让我们INSTANCE
ThreadLocal
开始吧。以这种方式修改类:
public class DAOManager {
public static DAOManager getInstance() {
return DAOManagerSingleton.INSTANCE.get();
}
public void open() throws SQLException {
try
{
if(this.con==null || !this.con.isOpen())
this.con = src.getConnection();
}
catch(SQLException e) { throw e; }
}
public void close() throws SQLException {
try
{
if(this.con!=null && this.con.isOpen())
this.con.close();
}
catch(SQLException e) { throw e; }
}
//Private
private DataSource src;
private Connection con;
private DAOManager() throws Exception {
try
{
InitialContext ctx = new InitialContext();
this.src = (DataSource)ctx.lookup("jndi/MYSQL");
}
catch(Exception e) { throw e; }
}
private static class DAOManagerSingleton {
public static final ThreadLocal<DAOManager> INSTANCE;
static
{
ThreadLocal<DAOManager> dm;
try
{
dm = new ThreadLocal<DAOManager>(){
@Override
protected DAOManager initialValue() {
try
{
return new DAOManager();
}
catch(Exception e)
{
return null;
}
}
};
}
catch(Exception e)
dm = null;
INSTANCE = dm;
}
}
}
我很乐意不这样做
catch(Exception e)
{
return null;
}
但initialValue()
不能抛出异常。哦,initialValue()
你的意思是?该方法将告诉我们ThreadLocal
变量将保留什么值。基本上,我们正在初始化它。因此,由于这个原因,我们现在每个线程可以有一个实例。
DAOManager
没有DAO,A 算不了什么。因此,我们至少应该创建其中的几个。
DAO(“数据访问对象”的简称)是一种设计模式,它赋予对表示特定表的类管理数据库操作的责任。
为了DAOManager
更有效地使用我们,我们将定义一个GenericDAO
,它是一个抽象的DAO,它将保留所有DAO之间的通用操作。
public abstract class GenericDAO<T> {
public abstract int count() throws SQLException;
//Protected
protected final String tableName;
protected Connection con;
protected GenericDAO(Connection con, String tableName) {
this.tableName = tableName;
this.con = con;
}
}
现在,这已经足够了。让我们创建一些DAO。假设我们有两个POJO:First
和Second
,都只有一个String
名为的字段data
及其getter和setter。
public class FirstDAO extends GenericDAO<First> {
public FirstDAO(Connection con) {
super(con, TABLENAME);
}
@Override
public int count() throws SQLException {
String query = "SELECT COUNT(*) AS count FROM "+this.tableName;
PreparedStatement counter;
try
{
counter = this.con.PrepareStatement(query);
ResultSet res = counter.executeQuery();
res.next();
return res.getInt("count");
}
catch(SQLException e){ throw e; }
}
//Private
private final static String TABLENAME = "FIRST";
}
SecondDAO
或多或少具有相同的结构,只是更改TABLENAME
为"SECOND"
。
DAOManager
不仅应充当单个连接点的目的。其实DAOManager
应该回答这个问题:
谁负责管理与数据库的连接?
各个DAO不应管理它们,而是DAOManager
。我们已经部分回答了这个问题,但是现在我们不应该让任何人管理与数据库的其他连接,甚至不能管理DAO。但是,DAO需要连接到数据库!谁提供?DAOManager
确实!我们应该做的是在内部创建工厂方法DAOManager
。不仅如此,DAOManager
还可以将当前连接交给他们!
Factory是一种设计模式,它使我们可以创建某个超类的实例,而无需确切知道将返回哪个子类。
首先,让我们创建一个enum
表列表。
public enum Table { FIRST, SECOND }
现在,里面的工厂方法DAOManager
:
public GenericDAO getDAO(Table t) throws SQLException
{
try
{
if(this.con == null || this.con.isClosed()) //Let's ensure our connection is open
this.open();
}
catch(SQLException e){ throw e; }
switch(t)
{
case FIRST:
return new FirstDAO(this.con);
case SECOND:
return new SecondDAO(this.con);
default:
throw new SQLException("Trying to link to an unexistant table.");
}
}
我们现在走了。尝试以下代码:
DAOManager dao = DAOManager.getInstance();
FirstDAO fDao = (FirstDAO)dao.getDAO(Table.FIRST);
SecondDAO sDao = (SecondDAO)dao.getDAO(Table.SECOND);
System.out.println(fDao.count());
System.out.println(sDao.count());
dao.close();
是不是花哨且易于阅读?不仅如此,当您调用时close()
,您还关闭了DAO正在使用的每个连接。但是如何?好吧,他们共享相同的连接,所以这很自然。
从现在开始,我们可以做几件事。要确保关闭连接并返回到池,请执行以下操作DAOManager
:
@Override
protected void finalize()
{
try{ this.close(); }
finally{ super.finalize(); }
}
您还可以实现封装的方法setAutoCommit()
,commit()
并rollback()
从中封装方法,Connection
以便更好地处理交易。我还做的是,不仅持有a Connection
,DAOManager
还持有a PreparedStatement
和a ResultSet
。因此,调用close()
时也会同时关闭两者。关闭语句和结果集的快速方法!
希望本指南对您的下一个项目有帮助!
本文收集自互联网,转载请注明来源。
如有侵权,请联系 [email protected] 删除。
我来说两句