hibernate創建資料庫連接

A. 請教hibernate連接mysql資料庫問題

首先需要先創建一個資料庫，打開Tomcat後在localhost/phpmyAdmin頁面新建一個資料庫，然後聲明欄位
首先在項目右邊打開Database頁面，添加一個資料庫，由於我用的是Mysql，選擇Mysql

填寫資料庫名稱後，由於沒有設置密碼，所以Users信息就填寫root，密碼留空，測試下Connection後，添加資料庫成功後就可以看到資料庫裡面的內容了

之後我們要做的就是添加Hibernate框架，右鍵項目 - add framework support，選擇Hibernate後，選擇Creata default hibernate configuration and main class和Import database schema，和新建Spring項目的時候一樣，選擇dowload，之後就會發現Hibernate讓你選擇綁定的資料庫，然後就可以選擇剛才打開的mysql，填寫Database的包名，就可以添加Hibernate框架了

B. hibernate連接h2資料庫配置怎麼寫

大家可以參考下這個網站http://eoffice.im.fju.e.tw/phpbb/viewtopic.php?p=28685

1.先啟動項目上的h2/bin下的h2.bat或h2w.bat文件，把h2資料庫啟動起來

2.SSH2框架和h2資料庫整合方法
2.1先在資料庫下創建 schema目錄(相當於一個資料庫實例)

create schema fdrkftcode
目的是解決這種異常 org.h2.jdbc.JdbcSQLException: Schema "fdrkftcode" not found; ...

2.2在schema目錄下創建表，如創建系統用戶表admin
create table fdrkftcode.admin(
id int primary key,
adminname varchar(50),
username varchar(50),
userpwd varchar(50),
adminrights varchar(50),
createdate datetime,
usedtimes int,
lastlogin datetime,
curstatus int,
remark varchar(200)
)

3.為了使用hibernate操作h2，需要作如下設置，在sql編輯窗口輸入下面這些腳本
對於實體pojo對象的映射，我是用的annotation，關鍵是id主鍵的映射，如下：
@Column(name = "ID", nullable = false)

@Id

@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "ABC_ID_SEQ")

@SequenceGenerator(name = "ABC_ID_SEQ", sequenceName = "ABC_ID_SEQ")

protected Long id;

注意這里的GeneratedValue和SequenceGenerator的使用，這屬於JPA規范，全部來自javax.persisten

4.配置applicationContext.xml文件,主要有三個地方要注意：
4.1修改連接資料庫的JDBC驅動 driverClass的值為org.h2.Driver
4.2修改連接資料庫所用的URL字元串 jdbcUrl的值為jdbc:h2:tcp://localhost/~/FDRKFTCODE;MODE=MySQL;AUTO_SERVER=TRUE
4.3修改Hibernate的資料庫方言hibernate.dialect為org.hibernate.dialect.H2Dialect

5.h2資料庫一些常用操作
5.1幫助命令help
5.2表中某欄位重命名 ALTER TABLE fdrkftcode.admin ALTER COLUMN usepwd rename to userpwd
5.3表中新增欄位 ALTER TABLE fdrkftcode.admin ADD IF NOT EXISTS abc varchar(50)
5.4表中刪除欄位 ALTER TABLE fdrkftcode.admin DROP COLUMN IF EXISTS abc
5.5查找表中記錄 SELECT * from fdrkftcode.admin
5.6往表中插入記錄 INSERT INTO fdrkftcode.admin VALUES (1,'管理員','admin','admin','10000000000000000000','2013-05-1 00:12:34',3,'2013-05-1 15:32:57',1,'超過級管理員')
5.7修改表中某記錄 UPDATE fdrkftcode.admin SET fdrkftcode.admin.adminname='超級管理員' where fdrkftcode.admin.id=1

5.8刪除表中某記錄 DELETE FROM fdrkftcode.admin WHERE fdrkftcode.admin.id=1
6.下面是我項目的applicationContext.xml配置方法，大家可以參考下
<?xml version="1.0" encoding="UTF-8"?>
<beans
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:p="http://www.springframework.org/schema/p"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

<!-- 定義使用C3P0連接池的數據源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<!-- 指定連接資料庫的JDBC驅動 -->
<property name="driverClass">
<value>org.h2.Driver</value>
</property>
<!-- 連接資料庫所用的URL -->
<property name="jdbcUrl">
<value>jdbc:h2:tcp://localhost/~/FDRKFTCODE;MODE=MySQL;AUTO_SERVER=TRUE</value>
</property>
<!-- 連接資料庫的用戶名 -->
<property name="user">
<value>sa</value>
</property>
<!-- 連接資料庫的密碼 -->
<property name="password">
<value></value>
</property>
<!-- 設置資料庫連接池的最大連接數 -->
<property name="maxPoolSize">
<value>50</value>
</property>
<!-- 設置資料庫連接池的最小連接數 -->
<property name="minPoolSize">
<value>5</value>
</property>
<!-- 設置資料庫連接池的初始化連接數 -->
<property name="initialPoolSize">
<value>5</value>
</property>
<!-- 設置資料庫連接池的連接的最大空閑時間,單位為秒 -->
<property name="maxIdleTime">
<value>20</value>
</property>
</bean>

<!-- 定義Hibernate的SessionFactory -->
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<!-- 依賴注入上面定義的數據源dataSource -->
<property name="dataSource" ref="dataSource"/>
<!-- 注冊Hibernate的ORM映射文件 -->
<property name="mappingResources">
<list>
<value>com/sungoal/ORM/Admin.hbm.xml</value>
</list>
</property>
<!-- 設置Hibernate的相關屬性 -->
<property name="hibernateProperties">
<props>
<!-- 設置Hibernate的資料庫方言 -->
<prop key="hibernate.dialect">org.hibernate.dialect.H2Dialect</prop>
<!-- 設置Hibernate是否在控制台輸出SQL語句，開發調試階段通常設為true -->
<prop key="show_sql">true</prop>
<!-- 設置Hibernate一個提交批次中的最大SQL語句數 -->
<prop key="hibernate.jdbc.batch_size">50</prop>
</props>
</property>
</bean>

<!--定義Hibernate的事務管理器HibernateTransactionManager -->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<!-- 依賴注入上面定義的sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 裝配通用資料庫訪問類BaseDAOImpl -->
<bean id="" class="com.sungoal.DAO.BaseDAOImpl">
<!-- 依賴注入上面定義的sessionFactory -->
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<!-- 部署系統用戶管理業務控制器AdminAction -->
<bean id="adminAction" class="com.sungoal.struts.action.AdminAction" scope="prototype">
<property name="" ref=""/>
</bean>
</beans>

C. hibernate連寫資料庫時,如何設置

Hibernate與各種資料庫連接的配置

1. Oracle連接配置
Oracler資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<!-- JDBC URL -->
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:dbname</property>
<!--資料庫用戶名-->
<property name="connection.username">test</property>
<!--資料庫密碼-->
<property name="connection.password">test</property>
上例使用的驅動類為：oracle.jdbc.driver.OracleDriver，開發人員需要將相關的jar包（ojdbc14.jar）加入到classpath中。

2. MySql連接配置
MySql資料庫的hibernate連接設置，在hibernate.cfg.xml文件中
<hibernate-configuration>
<session-factory>
<!--各屬性的配置-->
<!—為true表示將Hibernate發送給資料庫的sql顯示出來 -->
<property name="show_sql">true</property>
<!-- SQL方言，這邊設定的是MySQL -->
<property name="dialect">net.sf.hibernate.dialect.MySQLDialect</property>
<!--一次讀的資料庫記錄數 -->
<property name="jdbc.fetch_size">50</property>
<!--設定對資料庫進行批量刪除 -->
<property name="jdbc.batch_size">30</property>
<!--驅動程序-->
<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
<!-- JDBC URL -->
<property name="connection.url">jdbc:mysql://localhost/dbname?
characterEncoding=gb2312</property>
<!--資料庫用戶名-->
<property name="connection.username">root</property>
<!--資料庫密碼-->
<property name="connection.password">root</property>
<!—映射文件 -->
<mapping resource="com/amigo/pojo/User.hbm.xml"/>
<mapping resource="com/amigo/pojo/Org.hbm.xml"/>
</session-factory>
</hibernate-configuration>
上面使用的驅動類是com.mysql.jdbc.Driver.需要將MySql的連接器jar包（eg. mysql-connector-java-Dbname為資料庫名字5.0.4-bin.jar）加入到classpath中。

3. Sql Server連接配置
Sql Server資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">net.sourceforge.jtds.jdbc.Driver</property>
<!-- JDBC URL -->
<property
name="connection.url">jdbc:jtds:sqlserver://localhost:1433;DatabaseName=dbname</property>
<!--資料庫用戶名-->
<property name="connection.username">sa</property>
<!--資料庫密碼-->
<property name="connection.password"></property>
上例的驅動類使用的是jtds的驅動類，因此讀者需要將jtds的jar包（eg. jtds-1.2.jar）加入到classpath中

4. DB2連接配置
DB2資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class"> com.ibm.db2.jdbc.app.DB2Driver</property>
<!-- JDBC URL -->
<property
name="connection.url"> jdbc:db2://localhost:5000/sample </property> //sample為資料庫名
<!--資料庫用戶名-->
<property name="connection.username">admin</property>
<!--資料庫密碼-->
<property name="connection.password"></property>
上例使用的驅動類為：com.ibm.db2.jdbc.app.DB2Driver，開發人員需要將相關的jar包（db2jcc.jar）加入到classpath中。

5.sybase連接配置
sybase資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">com.sybase.jdbc.SybDrive</property>
<!-- JDBC URL -->
<property
name="connection.url"> jdbc:sybase:Tds:localhost:5007/myDB</property> ;//myDB為資料庫名
<!--資料庫用戶名-->
<property name="connection.username">userid</property>
<!--資料庫密碼-->
<property name="connection.password">user_password</property>
上例使用的驅動類為：com.sybase.jdbc.SybDrive，開發人員需要將相關的jar包（jconn3.jar）加入到classpath中。

6. informix連接配置
informix資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">com.informix.jdbc.IfxDrive</property>
<!-- JDBC URL -->
<property
name="connection.url">jdbc:informix-sqli://123.45.67.89:1533/myDB:INFORMIXSERVER=myserver </property> ;//myDB為資料庫名
<!--資料庫用戶名-->
<property name="connection.username">testuser</property>
<!--資料庫密碼-->
<property name="connection.password">testpassword</property>
上例使用的驅動類為：com.informix.jdbc.IfxDrive，開發人員需要將相關的jar包（ifxjdbc.jar）加入到classpath中。

7.PostgreSQL連接配置
PostpreSQL資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">org.postgresql.Driver</property>
<!-- JDBC URL -->
<property
name="connection.url">jdbc:postgresql://localhost/myDB</property>;//myDB為資料庫名
<!--資料庫用戶名-->
<property name="connection.username">myuser</property>
<!--資料庫密碼-->
<property name="connection.password">mypassword</property>
上例使用的驅動類為：com.informix.jdbc.IfxDrive，開發人員需要將相關的jar包（postgresql-8.1-405.jdbc3）加入到classpath中。

8.access連接配置
access資料庫的hibernate在配置文件中配置。
連接部分
<!--驅動程序-->
<property name="connection.driver_class">sun.jdbc.odbc.JdbcOdbcDriver</property>
<!-- JDBC URL -->
<property
name="connection.url">jdbc:odbc:Driver={MicroSoft..Access..Driver(*.mdb)};DBQ="+application.getRealPath("/Data/ReportDemo.mdb")</property> ;//myDB為資料庫名
<!--資料庫用戶名-->
<property name="connection.username">myuser</property>
<!--資料庫密碼-->
<property name="connection.password">mypassword</property>

D. hibernate 怎麼連資料庫

首先，我們把hibernate最基本的資料庫連接，使用mysql。 見一個java工程，見一個包名為book， 在book的包下加一個java類Book.java，
其代碼如下： package book; public class Book { private Integer id; private String name; private String writer; public Integer get hibernate最基本的資料庫連接，使用mysql。 見一個java工程，見一個包名為「book」

然後在在book的包下加一個java類Book.java，其代碼如下： package book; public class Book { private Integer id; private String name; private String writer; public Integer getId（） { return id; } public void setId（Integer id） { this.id = id; } public String getName（） { return name; } public void setName（String name） { this.name = name; } public String getWriter（） { return writer; } public void setWriter（String writer） { this.writer = writer; } }

E. hibernate怎麼連接mysql資料庫

首先，我們把hibernate最基本的資料庫連接，使用mysql。 見一個java工程，見一個包名為book， 在book的包下加一個java類Book.java，其代碼如下： package book; public class Book { private Integer id; private String name; private String writer; public Integer get hibernate最基本的資料庫連接，使用mysql。 見一個java工程，見一個包名為「book」

F. 使用hibernate註解，怎樣連接資料庫

資料庫不需要你連接阿，通過你的配置文件都可以看出，你配置好之後，hibernate幫你連上資料庫，而你想得到一個session，可以通過SessionFactory來創建，由於你是用的annotation而不是XML，那具體代碼如下：
Configuration cfg = new AnnotationConfiguration().config();
SessionFactory sf = cfg.buildSessionFactory();
Session session = sf.openSession();
這樣就創建了一個session之後，就可以對資料庫進行操作了。
但是用完別忘了釋放資源哦，
close。

G. hibernate如何創建資料庫

<hibernate-configuration></hibernate-configuration>
之間加上
<property name="hibernate.hbm2ddl.auto">create</property>

H. 怎樣在hibernate中使用資料庫連接池

有三種可以實施的解決方案：
1、使用hibernate自帶的連接池；
2、使用c3po包的連接池功能；
3、使用Proxool包的連接池功能；

第一種方案，就是在myeclipse產生的hibernate.cfg.xml中添加一個屬性：
<property >20</property>
第二種方案是：
<property >test</property>
<property >com.microsoft.jdbc.sqlserver.SQLServerDriver</property>
<property >jdbc:microsoft:sqlserver://localhost:1433;databasename=test</property>
<property >sa</property>
<property >123</property>
<property >2</property>
<property >10</property>
<property >1800</property>
<property >4</property>
<property >1</property>
<property >36000</property>
<property >2</property>
<property >10</property>
<property >1200</property>
<property >30</property>
<property >2</property>
<property >org.hibernate.connection.C3P0ConnectionProvider</property>

第三中方案是Proxool：
在hibernate.cfg.xml中添加：
<!-- Proxool Database connection settings -->

<property >org.hibernate.connection.ProxoolConnectionProvider</property>
<property >DBPool</property>
<property >Proxool.xml</property>

<property >org.hibernate.dialect.SQLServerDialect</property>

<property >false</property>

然後再添加一個Proxool.xml文件：
<?xml version="1.0" encoding="UTF-8"?>
<!-- the proxool configuration can be embedded within your own application's.
Anything outside the "proxool" tag is ignored. -->
<something-else-entirely>
<proxool>
<alias>DBPool</alias>
<driver-url>jdbc:microsoft:sqlserver://localhost:1433;databasename=test</driver-url>
<driver-class>com.microsoft.jdbc.sqlserver.SQLServerDriver</driver-class>
<driver-properties>
<property value="sa"/>
<property value="123"/>
</driver-properties>
<maximum-connection-count>10</maximum-connection-count>
</proxool>
</something-else-entirely>

這個三種方案，我都可以配置成功，可是，郁悶的是，這三種方案，都比我不用連接池的數據要慢，可能是我的測試不準確吧？我只做了連續100000次的數據插入操作

I. 如何用連接池，Hibernate，Spring連多個SQL資料庫

1：在proxool-conf.xml中配置兩個資料庫連接池
<proxool>
<alias>dataSource_ksmaeaII</alias>
<driver-url>jdbc:jtds:sqlserver://192.10.110.192:1433;databaseName=ksmaeaII</driver-url>
<driver-class>net.sourceforge.jtds.jdbc.Driver</driver-class>
<driver-properties>
<property name="user" value="sa" />
<property name="password" value="" />
</driver-properties>
<maximum-new-connections>100</maximum-new-connections>
<prototype-count>1</prototype-count>
<maximum-connection-count>400</maximum-connection-count>
<minimum-connection-count>20</minimum-connection-count>
<house-keeping-test-sql>select getdate()</house-keeping-test-sql>
</proxool>

<proxool>
<alias>ds1</alias>
<driver-url>jdbc:jtds:sqlserver://192.10.110.192:1433;databaseName=ksmaeaIIdbmove</driver-url>
<driver-class>net.sourceforge.jtds.jdbc.Driver</driver-class>
<driver-properties>
<property name="user" value="sa" />
<property name="password" value="" />
</driver-properties>
<maximum-new-connections>100</maximum-new-connections>
<prototype-count>1</prototype-count>
<maximum-connection-count>400</maximum-connection-count>
<minimum-connection-count>20</minimum-connection-count>
<house-keeping-test-sql>select getdate()</house-keeping-test-sql>
</proxool>

2：要連幾個庫就配置幾個hibernate.cfg.xml,下面我配置兩個資料庫為例
創建hibernate.cfg.xml:裡面寫第一個資料庫的映射文件（本地資料庫），如<mapping
resource="com/wisoft/datachange/data/hibernate//SbInfApply.hbm.xml" />
創建hibernate.cfg1.xml:裡面寫第二個資料庫的映射文件（前置庫，別人的資料庫），如<mapping
resource="com/wisoft/datachange/data/hibernate//InfApply.hbm.xml" />
3：創建一個類，繼承HibernateDaoSupport。（直接拷過去就能直接用，我的第二個資料庫就是用了這裡面的factory1,第一個資料庫用了Hibernate原來的factory,如果要連多個庫，則多創建幾個factory）
package com.wisoft.datachange.data;
import org.hibernate.SessionFactory;
import org.springframework.orm.hibernate3.HibernateTemplate;
import org.springframework.orm.hibernate3.support.HibernateDaoSupport;
public class DebugBean extends HibernateDaoSupport {
private SessionFactory factory1;
// private SessionFactory factory2;
protected HibernateTemplate hibernateTemplate1;
// protected HibernateTemplate hibernateTemplate2;

public void setFactory1(SessionFactory factory1) {
this.factory1 = factory1;
}
// public void setFactory2(SessionFactory factory2) {
// this.factory2 = factory2;
// }

public SessionFactory getFactory1() {
return factory1;
}
// public SessionFactory getFactory2() {
// return factory2;
// }
protected HibernateTemplate createHibernateTemplate(SessionFactory sessionFactory) {
return super.createHibernateTemplate(sessionFactory);
}
protected void initDao() throws Exception {
hibernateTemplate1 = super.createHibernateTemplate(factory1);
// hibernateTemplate2 = super.createHibernateTemplate(factory2);
super.initDao();
}
}
4：編寫自己的測試BO：在BO里注入DAO,如下
public class InfApplyBO implements IInfApplyBO {
private IInfApplyDAO myInfApplyDAO;
public IInfApplyDAO getMyInfApplyDAO() {
return myInfApplyDAO;
}
public void setMyInfApplyDAO(IInfApplyDAO myInfApplyDAO) {
this.myInfApplyDAO = myInfApplyDAO;
}
//底下編寫自己的業務代碼
//用this.myInfApplyDAO直接調用Dao層的方法，由DAO對資料庫進行操作
}
5：編寫自己的測試DAO：繼承DebugBean如下
public class MyInfApplyDAO extends DebugBean implements IInfApplyDAO {
//對資料庫的操作均可寫在這里，可以直接用模版save
//如要對第一個資料庫操作，只需this.getHibernateTemplate().find(hql);
//如要對第二個資料庫操作，只需hibernateTemplate1.save（obj）;就行
//注意：在對資料庫操作之前不要忘了寫applicationContext.xml的配置文件，看第6步
}
6：寫applicationContext.xml的配置文件
<!--對第一個資料庫連接池的配置-->
<bean id="dataSource_ksmaeaII" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.logicalcobwebs.proxool.ProxoolDriver</value>
</property>
<property name="url">
<value>proxool.dataSource_ksmaeaII</value>
</property>
</bean>

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="dataSource_ksmaeaII" />
</property>
<property name="lobHandler" ref="lobHandler" />
<property name="configLocation">
<value>classpath:hibernate.cfg.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.AllowCreate">true</prop>
<prop key="hibernate.connection.release_mode">auto</prop>
<prop key="hibernate.default_schema">dbo</prop>
</props>
</property>
</bean>

<!--對第二個資料庫連接池的配置-->
<bean id="ds1" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name="driverClassName">
<value>org.logicalcobwebs.proxool.ProxoolDriver</value>
</property>
<property name="url">
<value>proxool.ds1</value>
</property>
</bean>

<bean id="sessionFactory1" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource">
<ref bean="ds1" />
</property>
<property name="lobHandler" ref="lobHandler" />
<property name="configLocation">
<value>classpath:hibernate1.cfg.xml</value>
</property>
<property name="hibernateProperties">
<props>
<prop key="hibernate.dialect">org.hibernate.dialect.SQLServerDialect</prop>
<prop key="hibernate.show_sql">true</prop>
<prop key="hibernate.AllowCreate">true</prop>
</props>
</property>
</bean>
<!--配置事務-->
<bean id="transactionManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref local="sessionFactory" />
</property>
</bean>

<bean id="transactionManager1" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
<property name="sessionFactory">
<ref bean="sessionFactory1"/>
</property>
</bean>

<!--工廠模版-->
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTemplate">
<property name="sessionFactory" ref="sessionFactory" />
</bean>

<bean id="txProxyTemplate" abstract="true" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
<property name="transactionManager" ref="transactionManager" />
<property name="transactionAttributes">
<props>
<prop key="get*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="find*">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="save*">PROPAGATION_REQUIRED</prop>
<prop key="write">PROPAGATION_REQUIRED,readOnly</prop>
<prop key="makeWorkNoOfDep">PROPAGATION_REQUIRED</prop>
</props>
</property>
</bean>

<bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc." lazy-init="true" />
<bean id="lobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler">
<!-- <property name="nativeJdbcExtractor">
<ref bean="nativeJdbcExtractor" />
</property> -->
</bean>
<bean id="debugbean" class="com.wisoft.datachange.data.DebugBean" abstract="true">
<property name="sessionFactory" ref="sessionFactory" />
<property name="factory1" ref="sessionFactory1" />
<!-- <property name="factory2" ref="sessionFactory2" />-->
</bean>

<bean id="myInfApplyDAO"
class="com.wisoft.datachange.data.hibernate.MyInfApplyDAO" parent="debugbean" >
</bean>

<bean id="InfApplyBO" parent="txProxyTemplate">
<property name="target">
<bean class="com.wisoft.datachange.bo.impl.InfApplyBO">
<property name="myInfApplyDAO" ref="myInfApplyDAO" />
</bean>
</property>
</bean>

到此，資料庫就連起來啦\(^o^)/~