mongoDB（spring 部分配置）

 <!-- 定义mongo对象，对应的是mongodb官方jar包中的Mongo，replica-set设置集群副本的ip地址和端口 -->

 <mongo:mongo id="mongo" replica-set="${mongo.hostport}">

  <mongo:options

    connections-per-host="${mongo.connectionsPerHost}"

    threads-allowed-to-block-for-connection-multiplier="${mongo.threadsAllowedToBlockForConnectionMultiplier}"

    connect-timeout="${mongo.connectTimeout}"

    max-wait-time="${mongo.maxWaitTime}"

             auto-connect-retry="${mongo.autoConnectRetry}"

             socket-keep-alive="${mongo.socketKeepAlive}"

             socket-timeout="${mongo.socketTimeout}"

             slave-ok="${mongo.slaveOk}"

             write-number="1"

             write-timeout="0"

             write-fsync="true"

  />

 </mongo:mongo>

 

  <!-- mongo的工厂，通过它来取得mongo实例,dbname为mongodb的数据库名，没有的话会自动创建

  mongo-ref="mongo" 与<mongo:mongo id="mongo" 相依赖

  -->  

 <mongo:db-factory dbname="Data" mongo-ref="mongo"/>

 

 

     <!-- mongodb的主要操作对象，所有对mongodb的增删改查的操作都是通过它完成   -->

    <bean id="mongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">  

        <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />  

    </bean> 

 

 

#Mongodb 一  Setting

mongo.hostport=127.0.0.1:27017

mongo.connectionsPerHost=8

mongo.threadsAllowedToBlockForConnectionMultiplier=4

#连接超时时间

mongo.connectTimeout=1000

#等待时间

mongo.maxWaitTime=1500

mongo.autoConnectRetry=true

mongo.socketKeepAlive=true

#Socket超时时间

mongo.socketTimeout=1500

mongo.slaveOk=true

 

 

MySql（采用Proxool连接池技术）

---

Proxool是一种Java数据库连接池技术。

proxool-0.9.1.jar

proxool-cglib-0.9.1.jar

 

第一步：

在web.xml中调用对应的applicationContext-proxool.xml

例如：web.xml中的（*为通配符，可以查询到applicationContext-proxool.xml）

  <context-param>

       <param-name>contextConfigLocation</param-name>

       <param-value>classpath*:applicationContext*.xml</param-value>

  </context-param>

 

第二步：

在applicationContext-proxool.xml中写连接池

 <bean id="dataSourceTarget" class="org.logicalcobwebs.proxool.ProxoolDataSource"> 

  <property name="driver" value="${jdbc.driverClassName}" />

  <property name="driverUrl" value="${jdbc.url}"></property>

  <property name="user" value="${jdbc.username}" />

  <property name="password" value="${jdbc.password}" />

 

  <property name="alias" value="site_ds" />

  <!-- 最少保持的空闲连接数 -->

  <property name="prototypeCount" value="${proxool.prototypeCount}" />

  <!-- 允许最大连接数,超过了这个连接，再有请求时，就排在队列中等候，最大的等待请求数由simultaneousBuildThrottle决定 -->

  <property name="maximumConnectionCount" value="${proxool.maximumConnectionCount}" />

  <!-- 最小连接数 -->

  <property name="minimumConnectionCount" value="${proxool.minimumConnectionCount}" />

  <!-- 一个线程持有一个连接的最长时间，而不管这个连接是否处于 active 状态, 并且如果线程的持有时间超过这个时间的之后会自动清除掉这个连接.

   但是很多时候5分钟并不够用, 所以需要在配置文件中进行设置, 其单位为毫秒(ms). -->

  <property name="maximumActiveTime" value="86400000" />

  <!-- 指因未有空闲连接可以分配而在队列中等候的最大请求数,超过这个请求数的用户连接就不会被接受 -->

  <property name="simultaneousBuildThrottle" value="50" />

  <property name="houseKeepingTestSql" value="select CURRENT_DATE" />

</bean>

<!--
Spring官方推荐使用LazyConnectionDataSourceProxy
(http://static.springsource.org/spring/docs/2.5.6/api/org/springframework/jdbc/datasource/LazyConnectionDataSourceProxy.html)。 
目的： 1).解决Hiberante命中cache时，会对数据库发起SET autocommit=0,commit,SET autocommit=0操作问题； 
2).解决read_only事务对性能的影响问题 -->
<!-- 个人觉得是用来管理数据源的 -->
<bean id="dataSource"
class="org.springframework.jdbc.datasource.LazyConnectionDataSourceProxy">
<property name="targetDataSource">
<ref local="dataSourceTarget" />
</property>
</bean> 
<bean id="transactionManager"
class="org.springframework.jdbc.datasource.DataSourceTransactionManager" lazy-init="true">
<property name="dataSource" ref="dataSource" />
</bean>
<bean id= "nameMatch" class= "org.springframework.transaction.interceptor.NameMatchTransactionAttributeSource" >
    <property name= "properties" >
         <props>              
<prop key="*">PROPAGATION_REQUIRED</prop>
          </props>
    </property>
 </bean>

 <!--利用了拦截器的原理。 -->

 <bean id="transactionInterceptor"

  class="org.springframework.transaction.interceptor.TransactionInterceptor">

   <!--   事务拦截器bean需要依赖注入一个事务管理器 -->

  <property name="transactionManager">

   <ref bean="transactionManager" />

  </property>

  <!--事务传播属性 -->

  <property name="transactionAttributeSource">

   <ref bean="nameMatch" />

  </property>

 </bean>

 <bean id="txProxy"

  class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

  <property name="beanNames">

   <list>

    <value>*Manager</value>

    <value>*Service</value>

   </list>

  </property>

  <property name="interceptorNames">

   <list>

    <value>transactionInterceptor</value>

   </list>

  </property>

 </bean>

 <!--1:配置一个JdbcTemplate实例，并将这个“共享的”，“安全的”实例注入到不同的DAO类中去 -->

 <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

  <property name="dataSource" ref="dataSource"/>

 </bean> 

 

第三步：

由于在applicationContext-proxool.xml写参数麻烦，把参数写在applicationContext-database.properties

如下：

#SQL DB Settting

jdbc.driverClassName=com.mysql.jdbc.Driver

jdbc.url=jdbc:mysql://127.0.0.1:3306/database

jdbc.username=root

jdbc.password=root

proxool.maximumConnectionCount=50

proxool.minimumConnectionCount=1

proxool.prototypeCount=1