spring 3.0.6 + mybatis 3.06 + atomikos3.7 （tomcat）分布式事务

atomikos 所需jar :

1.transactions-jdbc.jar

2.transactions.jar

3.transactions-jta.jar

4.transactions-api.jar

5.atomikos-util.jar

jta.properties 配置文件 放在src目录即可

com.atomikos.icatch.service=com.atomikos.icatch.standalone.UserTransactionServiceFactory
com.atomikos.icatch.console_file_name = tm.out
com.atomikos.icatch.log_base_name = tmlog
com.atomikos.icatch.tm_unique_name = com.atomikos.spring.jdbc.tm
com.atomikos.icatch.console_log_level =INFO

spring配置文件

<!--   tomcat  数据源方式
    <jee:jndi-lookup id="dataSource1" jndi-name="jdbc/t1"/>
    <jee:jndi-lookup id="dataSource2" jndi-name="jdbc/t2"/>

-->

    
    
      <!--  读取数据库连接配置文件 -->
     <bean id="propertyConfig"
         class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="locations">
            <list>
                 <value>classpath:jdbc.properties</value>
             </list>
         </property>
     </bean>
   
   
    <!-- 第一个数据库   --> 
    <bean id="dataSource1" class="com.atomikos.jdbc.AtomikosDataSourceBean" 
        init-method="init" destroy-method="close">
        <property name="uniqueResourceName" value="mysql/product1" />
        <property name="xaDataSourceClassName"
            value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" /> 
        <property name="xaProperties">
            <props>
                <prop key="user">${jdbc.username.a}</prop>
                <prop key="password">${jdbc.password.a}</prop>
                <prop key="URL">${jdbc.url.a}</prop>
            </props>
        </property>
        <property name="testQuery"> 
            <value>SELECT 1</value> 
        </property>
    </bean> 
    <!-- 第二个数据库--> 
    <bean id="dataSource2" class="com.atomikos.jdbc.AtomikosDataSourceBean" 
        init-method="init" destroy-method="close">
        <property name="uniqueResourceName" value="mysql/product2" />
        <property name="xaDataSourceClassName"
            value="com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" /> 
        <property name="xaProperties">
            <props>
                <prop key="user">${jdbc.username.b}</prop>
                <prop key="password">${jdbc.password.b}</prop>
                <prop key="URL">${jdbc.url.b}</prop>
            </props>
        </property>
        <property name="testQuery"> 
            <value>SELECT 1</value> 
        </property>
    </bean>
   
    <!-- SessionFactory -->
    <bean id="sqlSessionFactory1" class="org.mybatis.spring.SqlSessionFactoryBean"> 
        <property name="dataSource" ref="dataSource1" />
    </bean>
   
    <bean id="sqlSessionFactory2" class="org.mybatis.spring.SqlSessionFactoryBean"> 
        <property name="dataSource" ref="dataSource2" />
    </bean> 
 
  <!--      
           spring管理atomikos 
-->
   
    <bean id="atomikosTransactionManager" class="com.atomikos.icatch.jta.UserTransactionManager"
                                    init-method="init" destroy-method="close">
        <description>UserTransactionManager</description>
        <property name="forceShutdown">
            <value>true</value>
        </property>
    </bean>
   
   
    <bean id="atomikosUserTransaction" class="com.atomikos.icatch.jta.UserTransactionImp"> 
        <property name="transactionTimeout" value="300" /> 
    </bean>
    
    <bean id="springTransactionManager" class="org.springframework.transaction.jta.JtaTransactionManager"> 
        <property name="transactionManager" ref="atomikosTransactionManager"/>
        <property name="userTransaction" ref="atomikosUserTransaction" />
        <property name="allowCustomIsolationLevels" value="true"/>
    </bean>
   
    <aop:aspectj-autoproxy />
   
    <aop:config  proxy-target-class="true"> 
        <aop:advisor pointcut="execution(* secoo.server.impl.*.*(..))"
            advice-ref="txAdvice" />
        </aop:config>
 
    <tx:advice id="txAdvice" transaction-manager="springTransactionManager"> 
        <tx:attributes>
            <tx:method name="insert*" propagation="REQUIRED" read-only="true" />
            <tx:method name="delete*" propagation="REQUIRED" read-only="true" />
            <tx:method name="update*" propagation="REQUIRED" read-only="true" />
            <tx:method name="*" propagation="SUPPORTS" rollback-for="Exception"  /> 
        </tx:attributes> 
    </tx:advice>

<!—mapping 配置 并且指定 用哪个ssessio工厂 -->

<bean id="product1" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="secoo.mapper.Product1"></property>
    <property name="sqlSessionFactory" ref="sqlSessionFactory1"></property>
</bean>

<bean id="product2" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="secoo.mapper.Product2"></property>
    <property name="sqlSessionFactory" ref="sqlSessionFactory2"></property>
</bean>

posted @ 2012-01-09 12:45 脚丫 阅读(243) 评论(0) 编辑

Redis 学习（二） 配置文件说明

转载：http://mxohy.blog.sohu.com/169635299.html

• daemonize 是否以后台进程运行，默认为no
  pidfile 如以后台进程运行，则需指定一个pid，默认为/var/run/redis.pid
  bind 绑定主机IP，默认值为127.0.0.1（默认注释掉的）
  port 监听端口，默认为6379
  timeout 超时时间，默认为300（秒）
  loglevel 日志记录等级，有4个可选值，debug，verbose（默认值），notice，warning
       debug：记录很多信息，用于开发和测试
       verbose：有用的信息，不像debug会记录那么多
       notice：普通的verbose，常用于生产环境
       warning：只有非常重要或者严重的信息会记录到日志
  logfile 日志记录方式，默认值为stdout，标准输出，若后台模式会输出到/dev/null
  databases 可用数据库数，默认值为16，默认数据库为0，数据库范围在0-（database-1）之间
        如连接到指定的数据库：redis-cli -n 1 –p 6379
  save <seconds> <changes> 指出在多长时间内，有多少次更新操作，就将数据同步到数据文件rdb。相当于条件触发抓取快照，这个可以多个条件配合，比如默认配置文件中的设置，就设置了三个条件。
       save 900 1  900秒内至少有1个key被改变
      save 300 10  300秒内至少有300个key被改变
      save 60 10000  60秒内至少有10000个key被改变
  rdbcompression 存储至本地数据库时（持久化到rdb文件）是否压缩数据，默认为yes
  dbfilename 本地持久化数据库文件名，默认值为dump.rdb
  dir 本地持久化数据库存放路径，默认值为 ./
  slaveof <masterip> <masterport> 当本机为slave时，设置主服务的IP及端口（默认注释掉的）
  masterauth <master-password> 当本机为slave时，设置连接master的密码（默认注释掉的）
  requirepass 数据库服务器采用了密码保护，连接密码（默认注释掉的）
  maxclients 最大客户端连接数，默认不限制（默认注释掉的）
  maxmemory <bytes> 设置最大内存，达到最大内存设置后，Redis会先尝试清除已到期或即将到期的Key，也会从free-list里清除一些key-value。当以上方法都没有效果，那redis就不再支持写入操作（如set，lpush），但不影响读操作如get。（默认注释掉的，没限制，跟RAM相同）
  maxmemory-policy volatile-lru，当redis达到设置的最大内存时redis处理方式：（默认注释掉的）
        volatile-lru：使用LRU算法清除过期的key
        allkeys-lru：使用LRU算法清除所有的key
        volatile-random：随机清除过期的一个key
        allkeys->random：随机清除任何一个key
        volatile-ttl：清除马上要过期的key
  appendonly 是否在每次更新操作后记录日志，默认值为no。如果不开启，会在断电时导致一段时间内的数据丢失（因为redis本身同步数据文件是save条件来同步的，所以有的数据会在一段时间内只存在于内存中）。若设置为yes，redis每次改变都会记录到appendonly.aof文件，每次redis重启后会redis会按顺序读取这个文件到内存中。
  注意：appendonly可以和save并存，但当重启时redis会读取aof文件到内存而忽略rdb文件。
  appendfilename 更新日志文件名，默认值为appendonly.aof（默认注释掉的）
  appendfsync 更新日志条件，共有3个可选值
       No：不调用fsync()，表示等操作系统进行数据缓存同步到磁盘，快
       Always：表示每次更新操作后都去调用fsync()将数据写到磁盘，慢，但安全
      Everysec：默认值，表示每秒同步一次，速度和安全性的均衡
  vm-enabled 是否使用虚拟内存，默认值为no，虚拟内存可以让redis使用比RAM还大的空间。
  vm-swap-file 虚拟内存文件路径，默认值为/tmp/redis.swap，不可多个Redis实例共享相同的swap文件，确保每个redis都有自己的vm swap
  注意：只有当vm-enabled设置为yes时才有效果。
  vm-max-memory 默认值为0。将所有大于vm-max-memory的数据存入虚拟内存，无论vm-max-memory设置多小，所有索引数据都是内存存储的 (Redis的索引数据就是keys)，也就是说当vm-max-memory设置为0的时候，表示将所有对象都存储在磁盘。
  建议将它设置为60%~80%的RAM，可以保护RAM，防止都被redis用光。
  vm-page-size 默认32，redis将swap划分为页，一个对象可以存储在多个连续的页里，一个页不能被不同的对象分享。所以如果页很大，但对象很小，则浪费了磁盘空间。
  如果有大量的小对象，可以将page设置为32或64bytes
  如果有大量的大对象，可以将page设置大些
  vm-pages 默认134217728，swap文件中内存页的总数，磁盘上每8页会消耗1byte的内存。
  所以swap总大小= vm-page-size * vm-pages
  vm-max-threads 默认4，VM IO的同时交换的最大并行数，若为0则关闭了VM功能。

posted @ 2012-01-09 10:21 脚丫 阅读(97) 评论(0) 编辑

spring + mybatis + atomikos 启动tomcat报错

DEBUG(DefaultListableBeanFactory.java:336)DefaultListableBeanFactory:336 - Ignoring bean class loading failure for bean 'atomikosTransactionManager'
org.springframework.beans.factory.CannotLoadBeanClassException: Error loading class [com.atomikos.icatch.jta.UserTransactionManager] for bean with name 'atomikosTransactionManager' defined in file [D:\tomcat-7\webapps\transcation\WEB-INF\classes\atomikos.xml]: problem with class file or dependent class; nested exception is java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
    at org.springframework.beans.factory.support.AbstractBeanFactory.resolveBeanClass(AbstractBeanFactory.java:1264)
    at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.predictBeanType(AbstractAutowireCapableBeanFactory.java:576)
    at org.springframework.beans.factory.support.AbstractBeanFactory.isFactoryBean(AbstractBeanFactory.java:1330)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanNamesForType(DefaultListableBeanFactory.java:317)
    at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeansOfType(DefaultListableBeanFactory.java:396)
    at org.springframework.context.support.AbstractApplicationContext.invokeBeanFactoryPostProcessors(AbstractApplicationContext.java:594)
    at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:407)
    at org.springframework.web.context.ContextLoader.createWebApplicationContext(ContextLoader.java:282)
    at org.springframework.web.context.ContextLoader.initWebApplicationContext(ContextLoader.java:204)
    at org.springframework.web.context.ContextLoaderListener.contextInitialized(ContextLoaderListener.java:47)
    at org.apache.catalina.core.StandardContext.listenerStart(StandardContext.java:4723)
    at org.apache.catalina.core.StandardContext$1.call(StandardContext.java:5226)
    at org.apache.catalina.core.StandardContext$1.call(StandardContext.java:5221)
    at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
    at java.util.concurrent.FutureTask.run(FutureTask.java:138)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908)
    at java.lang.Thread.run(Thread.java:619)
Caused by: java.lang.NoClassDefFoundError: javax/transaction/TransactionManager
    at java.lang.ClassLoader.defineClass1(Native Method)
    at java.lang.ClassLoader.defineClass(ClassLoader.java:621)
    at java.security.SecureClassLoader.defineClass(SecureClassLoader.java:124)
    at org.apache.catalina.loader.WebappClassLoader.findClassInternal(WebappClassLoader.java:2820)
    at org.apache.catalina.loader.WebappClassLoader.findClass(WebappClassLoader.java:1150)
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1645)
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1523)
    at org.springframework.util.ClassUtils.forName(ClassUtils.java:257)
    at org.springframework.beans.factory.support.AbstractBeanDefinition.resolveBeanClass(AbstractBeanDefinition.java:408)
    at org.springframework.beans.factory.support.AbstractBeanFactory.doResolveBeanClass(AbstractBeanFactory.java:1282)
    at org.springframework.beans.factory.support.AbstractBeanFactory.resolveBeanClass(AbstractBeanFactory.java:1253)
    ... 17 more
Caused by: java.lang.ClassNotFoundException: javax.transaction.TransactionManager
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1678)
    at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1523)
    at java.lang.ClassLoader.loadClassInternal(ClassLoader.java:320)
    ... 28 more
DEBUG(DefaultListableBeanFactory.java:336)DefaultListableBeanFactory:336 - Ignoring bean class loading failure for bean 'atomikosUserTransaction'
org.springframework.beans.factory.CannotLoadBeanClassException: Error loading class [com.atomikos.icatch.jta.UserTransactionImp] for bean with name 'atomikosUserTransaction' defined in file [D:\tomcat-7\webapps\transcation\WEB-INF\classes\atomikos.xml]: problem with class file or dependent class; nested exception is java.lang.NoClassDefFoundError: javax/transaction/UserTransaction

原因：缺少jta.jar 包。

posted @ 2012-01-09 10:16 脚丫 阅读(127) 评论(0) 编辑

Redis 学习 （三） 常用命令

转载：http://mxohy.blog.sohu.com/169635845.html常用redis操作命令：

常用redis操作命令：
1、手动抓取快照，save或者bgsave（后台异步）
redis> save
OK
redis> bgsave
Background saving started

2、获取某个key的类型
redis> type mylist
list

3、匹配所有符合模式的key，*代表所有
redis> keys *
1) "name"
2) "mylist"

4、随机返回一个key，
redis> randomkey
"mylist"

5、重命名一个key，
redis> rename name myname
OK
redis> keys *
1) "myname"
2) "mylist"

6、list的一些操作，
将一个值添加到列表的首部，
redis> rpush company taobao
(integer) 1
redis> lrange company 0 1
1)    "taobao"

将一个值添加到列表的尾部，
redis> lpush company sina
(integer) 2
redis> lrange company 0 1
1) "sina"
2) "taobao"

获得列表长度，
redis> llen company
(integer) 2

返回list中某个范围的值，模式LRANGE key start end
redis> lrange company 1 2
1) "taobao"
2) "sohu"

只保留list中某个范围的值，模式LTRIM key start end
redis> lrange company 0 2
1) "sina"
2) "taobao"
3) "sohu"
redis> ltrim company 0 1
OK
redis> lrange company 0 2
1) "sina"
2) "taobao"

获得list中某个索引号的值，模式LINDEX key index
redis> lrange company 0 4
1) "baidu"
2) "sohu"
3) "sina"
4) "taobao"
redis> lindex company 2
"sina"
redis> lindex company 0
"baidu"

设置list中某个索引位置的值，模式LSET key index value
redis> lrange company 0 4
1) "baidu"
2) "sohu"
3) "sina"
4) "taobao"
redis> lset company 2 google
OK
redis> lrange company 0 4
1) "baidu"
2) "sohu"
3) "google"
4) "taobao"

用lpop获取list中索引最小的值（头部值），rpop获取list中索引最大的值（尾部值），注意获取之后list中就不再有这个值了。
redis> lrange company 0 4
1) "baidu"
2) "sohu"
3) "google"
4) "taobao"
redis> lpop company
"baidu"
redis> rpop company
"taobao"
redis> lrange company 0 4
1) "sohu"
2) "google"

特别注意：以上这些命令中的start或者index都是从0开始计算的

7、集合的一些操作
向集合中增加一个元素，模式SADD key member
redis> sadd class kongxing
(integer) 1
redis> type class
set

列出集合中的所有元素，注意元素是无序的，模式SMEMBERS key
redis> smembers class
1) "banqiao"
2) "rulong"
3) "changjie"
4) "kongxing"

从集合中删除一个元素，模式SREM key member
redis> srem class kongxing
(integer) 1
redis> smembers class
1) "banqiao"
2) "rulong"
3) "changjie"

返回集合大小，模式SCARD key
redis> scard class
(integer) 3

判断某个值是否在集合中，模式SISMEMBER key member
redis> sismember class kongxing
(integer) 0—表示没有’kongxing’这个元素
redis> sismember class rulong
(integer) 1—表示存在’rulong’这个元素

获取多个集合的交集元素，模式SINTER key1 key2 ... keyN
redis> smembers dba
1) "rulong"
2) "changjie"
redis> smembers class
1) "banqiao"
2) "rulong"
3) "kongxing"
4) "changjie"
redis> sinter class dba
1) "rulong"
2) "changjie"
redis> sinter dba class
1) "rulong"
2) "changjie"
---注意：取交集，所以与各个key的位置无关 

posted @ 2012-01-05 11:29 脚丫 阅读(97) 评论(0) 编辑

Redis 学习 （一） 简介、安装

转载：http://mxohy.blog.sohu.com/169631115.html

Redis是什么

Redis是REmote DIctionary Server的缩写，Redis is an open source, advanced key-value store

Redis本质上一个Key/Value数据库，与Memcached类似的NoSQL型数据库，但是数据可以持久化的保存在磁盘上，解决了服务重启后数据不丢失的问题（但持久化有一些问题，后面再说吧），redis的值可以是string（字符串）、hashes、list（列表）、sets（集合）或者是sorted  sets（被排序的集合），（这是它最大的优势，其他nosql都只支持string），所有的数据类型都具有push/pop、add/remove、执行服务端的并集、交集、两个sets集中的差别等等操作，这些操作都是具有原子性的，Redis还支持各种不同的排序能力。

      Redis 2.0增加了很多新特性，如：提升了性能、增加了新的数据类型、更少的利用内存（AOF和VM，这两个比较重要，后面会具体说）。

      Redis支持绝大部分主流的开发语言，如：C、Java、C＃、PHP、Perl、Python、Lua、Erlang、Ruby等等。

对于redis的认识不同，使用场景也会不同，如果当做一个内存数据库，那可以用来替换mysql；如果当做一个可持久化的缓存或者data structure server，那可以用来保存一些频繁访问的数据，由于支持的类型比较多，所以可以替换如memcached的东西。（如果用key value存储则修改和删除比较麻烦，需要将全部数据读出再写入，用list就可以解决这个啦）

下面来看看Redis的安装配置，很简单的

Redis的官方网站：http://redis.io/，上面有相关的文档和最新版本的redis下载

我下载的redis安装文件：redis-2.2.1.tar.gz

解压：

$tar zxvf redis-2.2.1.tar.gz

$cd redis-2.2.1

$make

是的，redis只需要make就可以了，这之后会在src目录中产生几个可执行文件，redis-server，redis-cli，redis-benchmark，redis-check-aof，redis-check-dump

默认配置文件的位置：redis-2.2.1/redis.conf

为了方便可以将可执行文件的路径加到PATH里：

PATH=$PATH:$HOME/bin:/home/kongxing/redis-2.2.1/src

启动时如没有特殊说明将使用默认配置文件，也可以指定配置文件：

$redis-server redis.conf

查看监听的端口以及服务：

$netstat -an -t

Active Internet connections (servers and established)

Proto Recv-Q Send-Q Local Address Foreign Address State

tcp 0 0 127.0.0.1:199 0.0.0.0:* LISTEN

tcp 0 0 0.0.0.0:6379 0.0.0.0:* LISTEN

tcp 0 0 0.0.0.0:6380 0.0.0.0:* LISTEN

Redis server启动后，可以使用redis-cli登录客户端进行操作，当存在多个server时通过指定端口号-p和服务器-h来访问：

$redis-cli -p 6379

redis>

关闭redis：

$redis-cli -p 6380

redis> shutdown

查看redis有哪些key：

$redis-cli keys \*

或者

redis> keys *

查看redis状态情况：

$redis-cli info

或者

redis> info

posted @ 2012-01-05 11:10 脚丫 阅读(134) 评论(0) 编辑