精华内容
下载资源
问答
  • 非常好的理解遗传算法的例子

    千次阅读 2015-06-02 20:29:01
    它不再是从一般到特殊或从简单复杂地搜索假设,而是通过变异和重组当前已知最好假设来生成后续假设。此文系转载,未能找到最原始出处。遗传算法手工模拟计算示例为更好地理解遗传算法运算过程,下面用...

    遗传算法(genetic algorithm)是一种大致基于模拟进化的学习方法,其中的假设常被描述为二进制位串,位串的含义依赖于具体的应用。它不再是从一般到特殊或从简单到复杂地搜索假设,而是通过变异和重组当前已知的最好假设来生成后续的假设。

    此文系转载,未能找到最原始的出处。

    遗传算法的手工模拟计算示例

    为更好地理解遗传算法的运算过程,下面用手工计算来简单地模拟遗传算法的各个主要执行步骤。

    例:求下述二元函数的最大值:
    这里写图片描述

    (1) 个体编码
    遗传算法的运算对象是表示个体的符号串,所以必须把变量 x1, x2 编码为一种
    符号串。本题中,用无符号二进制整数来表示。
    因 x1, x2 为 0 ~ 7之间的整数,所以分别用3位无符号二进制整数来表示,将它
    们连接在一起所组成的6位无符号二进制数就形成了个体的基因型,表示一个可
    行解。
    例如,基因型 X=101110 所对应的表现型是:x=[ 5,6 ]。
    个体的表现型x和基因型X之间可通过编码和解码程序相互转换。

    (2) 初始群体的产生
    遗传算法是对群体进行的进化操作,需要给其淮备一些表示起始搜索点的初始
    群体数据。
    本例中,群体规模的大小取为4,即群体由4个个体组成,每个个体可通过随机
    方法产生。
    如:011101,101011,011100,111001

    (3) 适应度汁算
    遗传算法中以个体适应度的大小来评定各个个体的优劣程度,从而决定其遗传
    机会的大小。
    本例中,目标函数总取非负值,并且是以求函数最大值为优化目标,故可直接
    利用目标函数值作为个体的适应度。

    (4) 选择运算
    选择运算(或称为复制运算)把当前群体中适应度较高的个体按某种规则或模型遗传到下一代群体中。一般要求适应度较高的个体将有更多的机会遗传到下一代
    群体中。
    本例中,我们采用与适应度成正比的概率来确定各个个体复制到下一代群体中
    的数量。其具体操作过程是:
    • 先计算出群体中所有个体的适应度的总和 fi ( i=1.2,…,M );
    • 其次计算出每个个体的相对适应度的大小 fi / fi ,它即为每个个体被遗传
    到下一代群体中的概率,
    • 每个概率值组成一个区域,全部概率值之和为1;
    • 最后再产生一个0到1之间的随机数,依据该随机数出现在上述哪一个概率区
    域内来确定各个个体被选中的次数。
    这里写图片描述
    (5) 交叉运算
    交叉运算是遗传算法中产生新个体的主要操作过程,它以某一概率相互交换某
    两个个体之间的部分染色体。
    本例采用单点交叉的方法,其具体操作过程是:
    • 先对群体进行随机配对;
    • 其次随机设置交叉点位置;
    • 最后再相互交换配对染色体之间的部分基因。
    这里写图片描述
    (6) 变异运算
    变异运算是对个体的某一个或某一些基因座上的基因值按某一较小的概率进
    行改变,它也是产生新个体的一种操作方法。
    本例中,我们采用基本位变异的方法来进行变异运算,其具体操作过程是:
    • 首先确定出各个个体的基因变异位置,下表所示为随机产生的变异点位置,
    其中的数字表示变异点设置在该基因座处;
    • 然后依照某一概率将变异点的原有基因值取反。
    这里写图片描述
    对群体P(t)进行一轮选择、交叉、变异运算之后可得到新一代的群体p(t+1)。
    这里写图片描述
    从上表中可以看出,群体经过一代进化之后,其适应度的最大值、平均值都得
    到了明显的改进。事实上,这里已经找到了最佳个体“111111”。
    [注意]
    需要说明的是,表中有些栏的数据是随机产生的。这里为了更好地说明问题,
    我们特意选择了一些较好的数值以便能够得到较好的结果,而在实际运算过程中
    有可能需要一定的循环次数才能达到这个最优结果。
    这里写图片描述

    展开全文
  • 这种功能一般都是通过cookie来实现。本篇文章将简单说一下如何使用php实现该需求。当然实现该需求方法有N多种。 整个过程就是用户在登陆时候,如果选择了记住密码或者一周内免登陆等这个选项时候,则在...
  • 一般用decimal,长度18,保存2位小数,具体看业务 在java开发中,货币在数据库中MySQL常用Decimal和Numric类型表示,这两种类型被MySQL实现为同样类型。他们被用于保存值,该值准确精度是极其重要值,例如与...

    一般用decimal,长度18,保存2位小数,具体看业务
    在java的开发中,货币在数据库中MySQL常用Decimal和Numric类型表示,这两种类型被MySQL实现为同样的类型。他们被用于保存值,该值的准确精度是极其重要的值,例如与金钱有关的数据。当声明一个类是这些类型之一时,精度和规模的能被(并且通常是)指定;例如:

    salary DECIMAL(9,2)

    在这个例子中,9(precision)代表将被用于存储值的总的小数位数,而2(scale)代表将被用于存储小数点后的位数。因此,在这种情况下,能被存储在salary列中的值的范围是从-9999999.99到9999999.99。

           DECIMAL和NUMERIC值作为字符串存储,而不是作为二进制浮点数,以便保存那些值的小数精度。一个字符用于值的每一位、小数点(如果scale>0)和“-”符号(对于负值)。如果scale是0,DECIMAL和NUMERIC值不包含小数点或小数部分。
    
           不使用float或者double的原因:因为float和double是以二进制存储的,所以有一定的误差。
    

    比如:在数据库中c1,c2,c3分别存储类型是float(10.2),decimal(10.2),float类型。
    插入数据:
    在这里插入图片描述
    INTO test (c1,c2,c3) VALUES (1234567.23,1234567.23,1234567.23)
    在这里插入图片描述

    展开全文
  • IoC基础例子

    2016-05-04 10:57:00
    一个简单的例子一般新建一个com.dao包,存放一些dao接口。 com.dao.impl里面存放具体的dao com.service存放service接口 com.service.impl具体的service serviceImpl里面定义一个dao的对象,使用service的...

    一个简单的例子:

    一般新建一个com.dao包,存放一些dao接口。

    com.dao.impl里面存放具体的dao

    com.service存放service接口

    com.service.impl具体的service

    serviceImpl里面定义一个dao的对象,使用service的对应方法调用到dao的对应方法

    接口的定义是因为java中推荐使用接口编程

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans" 
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
           xsi:schemaLocation="http://www.springframework.org/schema/beans
               http://www.springframework.org/schema/beans/spring-beans.xsd
               ">
    
        <!--<bean id="dog" class="com.Model.Dog" >
            <constructor-arg index="0" value="阿旺"></constructor-arg>
            <constructor-arg index="1" value="5"></constructor-arg>
        </bean>
        --><bean id="idaoImpl" class="com.dao.impl.IDaoImpl"></bean>
        <bean id="serviceImpl" class="com.service.impl.ServiceImpl">
            <property name="dao" ref="idaoImpl"></property>
        </bean>
    </beans>

    使用applicationContext对象获取bean容器中的实例化对象

                ApplicationContext ac=
                    new ClassPathXmlApplicationContext("com/test/applicationContext.xml");
                IService hello=(IService) ac.getBean("serviceImpl");

     

    Service、DAO层是作为独立的组件出现的。在编码阶段,即没有实例化对象,也没有设置依赖关系,而是把它交给Spring,由Spring在运行阶段实例化、组装对象,然后一步步执行的做法,因此被称为反向控制,或者反转控制。

    spring在运行阶段会把所有的bean实例化,所以不需要的在构造方法中的输出可以省去,免得。。。

    展开全文
  • 一般情况下,需要将事务提升业务层,即 Service 层。这样做是为了能够使用事务特性来管理具体的业务。 在 Spring 中通常可以通过以下三种方式来实现对事务管理: (1)使用Spring 事务代理工厂管理事务 ...

    Spring的事务管理:

      事务原本是数据库中的概念,在 Dao 层。但一般情况下,需要将事务提升到业务层,即 Service 层。这样做是为了能够使用事务的特性来管理具体的业务。  
      在 Spring 中通常可以通过以下三种方式来实现对事务的管理: 
        (1)使用 Spring 的事务代理工厂管理事务 
        (2)使用 Spring 的事务注解管理事务 
        (3)使用 AspectJ 的 AOP 配置管理事务 

      Spring事务管理API:

        Spring 的事务管理,主要用到两个事务相关的接口。

        (1)事务管理器接口 
            事务管理器是 PlatformTransactionManager 接口对象。其主要用于完成事务的提交、回滚,及获取事务的状态信息。查看 SpringAPI 帮助文档:Spring 框架解压目录下的docs/javadoc-api/index.html。

    Modifier and TypeMethod and Description
    void commit(TransactionStatus status)
    Commit the given transaction, with regard to its status.
    TransactionStatus getTransaction(TransactionDefinition definition)
    Return a currently active transaction or create a new one, according to the specified propagation behavior.
    void rollback(TransactionStatus status)
    Perform a rollback of the given transaction.

          A、常用的两个实现类 
            PlatformTransactionManager 接口有两个常用的实现类:  
              DataSourceTransactionManager:使用 JDBC 或 iBatis  进行持久化数据时使用。  
              HibernateTransactionManager:使用 Hibernate 进行持久化数据时使用。 
          B、Spring 的回滚方式 
            Spring 事务的默认回滚方式是:发生运行时异常时回滚,发生受查异常时提交。不过,对于受查异常,程序员也可以手工设置其回滚方式。

        (2)事务定义接口:
          事务定义接口 TransactionDefinition 中定义了事务描述相关的三类常量:事务隔离级别、事务传播行为、事务默认超时时限,及对它们的操作。

          A、定义了五个事务隔离级别常量: 
            这些常量均是以 ISOLATION_开头。即形如 ISOLATION_XXX。 
              DEFAULT:采用DB默认的事务隔离级别。MySql的默认为REPEATABLE_READ;  Oracle默认为 READ_COMMITTED。 
              READ_UNCOMMITTED:读未提交。未解决任何并发问题。 
              READ_COMMITTED:读已提交。解决脏读,存在不可重复读与幻读。  
              REPEATABLE_READ:可重复读。解决脏读、不可重复读,存在幻读  
              SERIALIZABLE:串行化。不存在并发问题。

          B、定义了七个事务传播行为常量 
            所谓事务传播行为是指,处于不同事务中的方法在相互调用时,执行期间事务的维护情况。如,A 事务中的方法 doSome()调用 B 事务中的方法 doOther(),在调用执行期间事务的维护情况,就称为事务传播行为。事务传播行为是加在方法上的。  
    事务传播行为常量都是以 PROPAGATION_  开头,形如 PROPAGATION_XXX。  
              REQUIRED:指定的方法必须在事务内执行。若当前存在事务,就加入到当前事务中;若当前没有事务,则创建一个新事务。这种传播行为是最常见的选择,也是Spring 默认的事务传播行为。  
              如该传播行为加在 doOther()方法上。若 doSome()方法在执行时就是在事务内的,则 doOther()方法的执行也加入到该事务内执行。若 doSome()方法没有在事务内执行,则 doOther()方法会创建一个事务,并在其中执行。

              SUPPORTS:指定的方法支持当前事务,但若当前没有事务,也可以以非事务方式执行。 

              MANDATORY:指定的方法必须在当前事务内执行,若当前没有事务,则直接抛出异常。

              REQUIRES_NEW:总是新建一个事务,若当前存在事务,就将当前事务挂起,直到新事务执行完毕。

              NOT_SUPPORTED:指定的方法不能在事务环境中执行,若当前存在事务,就将当前事务挂起。

              NEVER:指定的方法不能在事务环境下执行,若当前存在事务,就直接抛出异常。

              NESTED:指定的方法必须在事务内执行。若当前存在事务,则在嵌套事务内执行;若当前没有事务,则创建一个新事务。

          C、定义了默认事务超时时限 
            常量 TIMEOUT_DEFAULT 定义了事务底层默认的超时时限,及不支持事务超时时限设置的 none 值。 
            注意,事务的超时时限起作用的条件比较多,且超时的时间计算点较复杂。所以,该值一般就使用默认值即可。

     

      Spring事务代码详解:

        要求:实现模拟购买股票。存在两个实体:银行账户 Account 与股票账户 Stock。当要购买股票时,需要从 Account 中扣除相应金额的存款,然后在 Stock 中增加相应的股票数量。而在这个过程中,可能会抛出一个用户自定义的异常。异常的抛出,将会使两个操作回滚。 

        Step1:创建数据库表 account、stock
        Step2:创建实体类 Account 与 Stock (略)
        Step3:定义 Dao 接口  IAccountDao 与 IStockDao 

    复制代码
    1 package com.tongji.dao;
    2 
    3 public interface IAccountDao {
    4 
    5     void insertAccount(String aname, double money);
    6 
    7     void updateAccount(String aname, double money, boolean isBuy);
    8 
    9 }
    复制代码
    复制代码
    1 package com.tongji.dao;
    2 
    3 public interface IStockDao {
    4 
    5     void insertStock(String sname, int amount);
    6 
    7     void updateStock(String sname, int amount, boolean isBuy);
    8 
    9 }
    复制代码

        Step4:定义 Dao 实现类 AccountDaoImpl 与 StockDaoImpl

    复制代码
     1 package com.tongji.dao;
     2 
     3 import org.springframework.jdbc.core.support.JdbcDaoSupport;
     4 
     5 public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao {
     6 
     7     @Override
     8     public void insertAccount(String aname, double money) {
     9         String sql = "insert into account(aname, balance) values(?,?)";
    10         this.getJdbcTemplate().update(sql, aname, money);
    11     }
    12 
    13     @Override
    14     public void updateAccount(String aname, double money, boolean isBuy) {
    15         String sql = "update account set balance=balance+? where aname=?";
    16         if (isBuy) {
    17             sql = "update account set balance=balance-? where aname=?";
    18         }
    19         this.getJdbcTemplate().update(sql, money, aname);
    20         
    21     }
    22 
    23 }
    复制代码
    复制代码
     1 package com.tongji.dao;
     2 
     3 import org.springframework.jdbc.core.support.JdbcDaoSupport;
     4 
     5 public class StockDaoImpl extends JdbcDaoSupport implements IStockDao {
     6 
     7     @Override
     8     public void insertStock(String sname, int amount) {
     9         String sql = "insert into stock(sname, count) values (?,?)";
    10         this.getJdbcTemplate().update(sql , sname, amount);
    11     }
    12 
    13     @Override
    14     public void updateStock(String sname, int amount, boolean isBuy) {
    15         //isBuy为true,则表示购买股票,此时应增加股票账户中的股票数量
    16         String sql = "update stock set count=count-? where sname=?";
    17         if (isBuy) {
    18             sql = "update stock set count=count+? where sname=?";
    19         }
    20         this.getJdbcTemplate().update(sql, amount, sname);
    21     }
    22 
    23 }
    复制代码

        Step5:定义异常类 StockException

    复制代码
     1 package com.tongji.beans;
     2 
     3 public class StockException extends Exception {
     4     private static final long serialVersionUID = 5377570098437361228L;
     5 
     6     public StockException() {
     7         super();
     8     }
     9 
    10     public StockException(String message) {
    11         super(message);
    12     }
    13     
    14 }
    复制代码

        Step6:定义 Service 接口 IStockProcessService

    复制代码
    1 package com.tongji.service;
    2 
    3 public interface IStockProcessService {
    4     void openAccount(String aname, double money);
    5     void openStock(String sname, int amount);
    6     void buyStock(String aname, double money, String sname, int amount);
    7 }
    复制代码

        Step7:定义 service 的实现类 StockProcessServiceImpl

    复制代码
     1 package com.tongji.service;
     2 
     3 import org.springframework.transaction.annotation.Isolation;
     4 import org.springframework.transaction.annotation.Propagation;
     5 import org.springframework.transaction.annotation.Transactional;
     6 
     7 import com.tongji.beans.StockException;
     8 import com.tongji.dao.IAccountDao;
     9 import com.tongji.dao.IStockDao;
    10 
    11 public class StockProcessServiceImpl implements IStockProcessService{
    12      private IAccountDao accountDao;
    13      private IStockDao stockDao;
    14     
    15     public void setAccountDao(IAccountDao accountDao) {
    16         this.accountDao = accountDao;
    17     }
    18 
    19     public void setStockDao(IStockDao stockDao) {
    20         this.stockDao = stockDao;
    21     }
    22 
    23     @Override
    24     public void openAccount(String aname, double money) {
    25         accountDao.insertAccount(aname, money);
    26     }
    27 
    28     @Override
    29     public void openStock(String sname, int amount) {
    30         stockDao.insertStock(sname, amount);
    31     }
    32 
    33     @Override
    34     public void buyStock(String aname, double money, String sname, int amount) throws StockException {
    35         boolean isBuy = true;
    36         accountDao.updateAccount(aname, money, isBuy);
    37         //故意抛出异常
    38         if (true) {
    39             throw new StockException("购买股票异常");
    40         }
    41         stockDao.updateStock(sname, amount, isBuy);
    42     }
    43 
    44 }
    复制代码

        Step8:定义Spring 配置文件 

    复制代码
     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
     5         http://www.springframework.org/schema/beans 
     6         http://www.springframework.org/schema/beans/spring-beans.xsd
     7         http://www.springframework.org/schema/context 
     8         http://www.springframework.org/schema/context/spring-context.xsd">
     9     
    10     <!-- 注册数据源:C3P0数据源 -->
    11     <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    12         <property name="driverClass" value="${jdbc.driverClass}" />
    13         <property name="jdbcUrl" value="${jdbc.url}" />
    14         <property name="user" value="${jdbc.user}" />
    15         <property name="password" value="${jdbc.password}" />
    16     </bean>
    17     
    18     <!-- 注册JDBC属性文件 -->
    19     <context:property-placeholder location="classpath:jdbc.properties"/>
    20     
    21     <!-- 注册Dao -->
    22     <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
    23         <property name="dataSource" ref="myDataSource"/>
    24     </bean>
    25     <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
    26         <property name="dataSource" ref="myDataSource"/>
    27     </bean>
    28     <!-- 注册Service -->
    29     <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
    30         <property name="accountDao" ref="accountDao"/>
    31         <property name="stockDao" ref="stockDao"/>
    32     </bean>    
    33 </beans>
    复制代码

        Step9:测试类

    复制代码
     1 package com.tongji.test;
     2 
     3 import org.junit.Before;
     4 import org.junit.Test;
     5 import org.springframework.context.ApplicationContext;
     6 import org.springframework.context.support.ClassPathXmlApplicationContext;
     7 
     8 import com.tongji.service.IStockProcessService;
     9 
    10 public class MyTest {
    11     
    12     private IStockProcessService service;
    13 
    14     @Before
    15     public void before() {
    16         //创建容器
    17         @SuppressWarnings("resource")
    18         ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    19         service = (IStockProcessService) ac.getBean("stockService");
    20     }
    21     
    22     @Test
    23     public void testOpen() {
    24         service.openAccount("张三", 10000);
    25         service.openStock("华为", 5);
    26     }
    27     
    28     @Test
    29     public void testBuyStock() {
    30         service.buyStock("张三", 2000, "华为", 5);
    31     }
    32     
    33 }
    复制代码

        此配置文件没有采用事务管理,所以购买股票的时候,出现了数据库中账户金额减少了,但是股票数目没有增加的不一致情况。

      

      使用 Spring 的事务代理工厂管理事务:

        该方式是,需要为目标类,即 Service 的实现类创建事务代理。事务代理使用的类是TransactionProxyFactoryBean,该类需要初始化如下一些属性: 
          (1)transactionManager:事务管理器 
          (2)target:目标对象,即 Service 实现类对象 
          (3)transactionAttributes:事务属性设置 
          对于 XML 配置代理方式实现事务管理时,受查异常的回滚方式,程序员可以通过以下方式进行设置:通过“-异常”方式,可使发生指定的异常时事务回滚;通过“+异常”方式,可使发生指定的异常时事务提交。

        修改Spring配置文件:

    复制代码
     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4     xmlns:context="http://www.springframework.org/schema/context" xsi:schemaLocation="
     5         http://www.springframework.org/schema/beans 
     6         http://www.springframework.org/schema/beans/spring-beans.xsd
     7         http://www.springframework.org/schema/context 
     8         http://www.springframework.org/schema/context/spring-context.xsd">
     9     
    10     <!-- 注册数据源:C3P0数据源 -->
    11     <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    12         <property name="driverClass" value="${jdbc.driverClass}" />
    13         <property name="jdbcUrl" value="${jdbc.url}" />
    14         <property name="user" value="${jdbc.user}" />
    15         <property name="password" value="${jdbc.password}" />
    16     </bean>
    17     
    18     <!-- 注册JDBC属性文件 -->
    19     <context:property-placeholder location="classpath:jdbc.properties"/>
    20     
    21     <!-- 注册Dao -->
    22     <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
    23         <property name="dataSource" ref="myDataSource"/>
    24     </bean>
    25     <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
    26         <property name="dataSource" ref="myDataSource"/>
    27     </bean>
    28     <!-- 注册Service -->
    29     <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
    30         <property name="accountDao" ref="accountDao"/>
    31         <property name="stockDao" ref="stockDao"/>
    32     </bean>    
    33     
    34     <!-- 事务 -->
    35     <!-- 注册事务管理器 -->
    36     <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    37         <property name="dataSource" ref="myDataSource"/>
    38     </bean>
    39     <!-- 生成事务代理 -->
    40     <bean id="stockServiceProxy" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean">
    41         <property name="transactionManager" ref="myTxManager"/>
    42         <property name="target" ref="stockService"/>
    43         <property name="transactionAttributes">
    44             <props>
    45                 <prop key="open*">ISOLATION_DEFAULT,PROPAGATION_REQUIRED</prop>
    46                 <prop key="buyStock">ISOLATION_DEFAULT,PROPAGATION_REQUIRED,-StockException</prop>
    47             </props>
    48         </property>
    49     </bean>
    50 </beans>
    复制代码

        由于本项目使用的是 JDBC 进行持久化,所以使用 DataSourceTransactionManager 类作为事务管理器。

        修改测试类:

         public void before() {
               //创建容器
               @SuppressWarnings("resource")
               ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
               service = (IStockProcessService) ac.getBean("stockServiceProxy");
           }

     

      使用 Spring 的事务注解管理事务:
        通过@Transactional 注解方式,也可将事务织入到相应方法中。而使用注解方式,只需在配置文件中加入一个 tx 标签,以告诉 spring 使用注解来完成事务的织入。该标签只需指定一个属性,事务管理器。

        修改Spring配置文件:

    复制代码
     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4         xmlns:context="http://www.springframework.org/schema/context"
     5         xmlns:aop="http://www.springframework.org/schema/aop"
     6         xmlns:tx="http://www.springframework.org/schema/tx" 
     7         xsi:schemaLocation="
     8         http://www.springframework.org/schema/beans 
     9         http://www.springframework.org/schema/beans/spring-beans.xsd
    10         http://www.springframework.org/schema/context 
    11         http://www.springframework.org/schema/context/spring-context.xsd
    12         http://www.springframework.org/schema/tx 
    13         http://www.springframework.org/schema/tx/spring-tx.xsd
    14         http://www.springframework.org/schema/aop 
    15         http://www.springframework.org/schema/aop/spring-aop.xsd">
    16     
    17     <!-- 注册数据源:C3P0数据源 -->
    18     <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    19         <property name="driverClass" value="${jdbc.driverClass}" />
    20         <property name="jdbcUrl" value="${jdbc.url}" />
    21         <property name="user" value="${jdbc.user}" />
    22         <property name="password" value="${jdbc.password}" />
    23     </bean>
    24     
    25     <!-- 注册JDBC属性文件 -->
    26     <context:property-placeholder location="classpath:jdbc.properties"/>
    27     
    28     <!-- 注册Dao -->
    29     <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
    30         <property name="dataSource" ref="myDataSource"/>
    31     </bean>
    32     <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
    33         <property name="dataSource" ref="myDataSource"/>
    34     </bean>
    35     <!-- 注册Service -->
    36     <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
    37         <property name="accountDao" ref="accountDao"/>
    38         <property name="stockDao" ref="stockDao"/>
    39     </bean>    
    40     
    41     <!-- 事务 -->
    42     <!-- 注册事务管理器 -->
    43     <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    44         <property name="dataSource" ref="myDataSource"/>
    45     </bean>
    46     <!-- 开启注解驱动 -->
    47     <tx:annotation-driven transaction-manager="myTxManager"/>
    48 </beans>
    复制代码

        修改 service 的实现类 StockProcessServiceImpl:

    复制代码
     1 package com.tongji.service;
     2 
     3 import org.springframework.transaction.annotation.Isolation;
     4 import org.springframework.transaction.annotation.Propagation;
     5 import org.springframework.transaction.annotation.Transactional;
     6 
     7 import com.tongji.beans.StockException;
     8 import com.tongji.dao.IAccountDao;
     9 import com.tongji.dao.IStockDao;
    10 
    11 public class StockProcessServiceImpl implements IStockProcessService{
    12      private IAccountDao accountDao;
    13      private IStockDao stockDao;
    14     
    15     public void setAccountDao(IAccountDao accountDao) {
    16         this.accountDao = accountDao;
    17     }
    18 
    19     public void setStockDao(IStockDao stockDao) {
    20         this.stockDao = stockDao;
    21     }
    22 
    23     @Override
    24     @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED)
    25     public void openAccount(String aname, double money) {
    26         accountDao.insertAccount(aname, money);
    27     }
    28 
    29     @Override
    30     @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED)
    31     public void openStock(String sname, int amount) {
    32         stockDao.insertStock(sname, amount);
    33     }
    34 
    35     @Override
    36     @Transactional(isolation=Isolation.DEFAULT, propagation=Propagation.REQUIRED, rollbackFor=StockException.class)
    37     public void buyStock(String aname, double money, String sname, int amount) throws StockException {
    38         boolean isBuy = true;
    39         accountDao.updateAccount(aname, money, isBuy);
    40         if (true) {
    41             throw new StockException("购买股票异常");
    42         }
    43         stockDao.updateStock(sname, amount, isBuy);
    44     }
    45 
    46 }
    复制代码

        @Transactional 的所有可选属性如下所示: 
          propagation:用于设置事务传播属性。该属性类型为 Propagation 枚举,默认值为Propagation.REQUIRED。 
          isolation:用于设置事务的隔离级别。该属性类型为 Isolation 枚举,默认值为Isolation.DEFAULT。 
          readOnly:用于设置该方法对数据库的操作是否是只读的。该属性为 boolean,默认值为 false。 
          timeout:用于设置本操作与数据库连接的超时时限。单位为秒,类型为 int,默认值为-1,即没有时限。 
          rollbackFor:指定需要回滚的异常类。类型为 Class[],默认值为空数组。当然,若只有一个异常类时,可以不使用数组。 
          rollbackForClassName:指定需要回滚的异常类类名。类型为 String[],默认值为空数组。当然,若只有一个异常类时,可以不使用数组。 
          noRollbackFor:指定不需要回滚的异常类。类型为 Class[],默认值为空数组。当然,若只有一个异常类时,可以不使用数组。 
          noRollbackForClassName:指定不需要回滚的异常类类名。类型为 String[],默认值为空数组。当然,若只有一个异常类时,可以不使用数组。 
         需要注意的是,@Transactional 若用在方法上,只能用于 public 方法上。对于其他非public 方法,如果加上了注解@Transactional,虽然 Spring 不会报错,但不会将指定事务织入到该方法中。因为 Spring 会忽略掉所有非 public 方法上的@Transaction 注解。  
        若@Transaction 注解在类上,则表示该类上所有的方法均将在执行时织入事务。 

      使用 AspectJ 的 AOP 配置管理事务(重点):

        使用 XML 配置事务代理的方式的不足是,每个目标类都需要配置事务代理。当目标类较多,配置文件会变得非常臃肿。使用 XML 配置顾问方式可以自动为每个符合切入点表达式的类生成事务代理。

        修改Spring配置文件:

    复制代码
     1 <?xml version="1.0" encoding="UTF-8"?>
     2 <beans xmlns="http://www.springframework.org/schema/beans"
     3         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
     4         xmlns:context="http://www.springframework.org/schema/context"
     5         xmlns:aop="http://www.springframework.org/schema/aop"
     6         xmlns:tx="http://www.springframework.org/schema/tx" 
     7         xsi:schemaLocation="
     8         http://www.springframework.org/schema/beans 
     9         http://www.springframework.org/schema/beans/spring-beans.xsd
    10         http://www.springframework.org/schema/context 
    11         http://www.springframework.org/schema/context/spring-context.xsd
    12         http://www.springframework.org/schema/tx 
    13         http://www.springframework.org/schema/tx/spring-tx.xsd
    14         http://www.springframework.org/schema/aop 
    15         http://www.springframework.org/schema/aop/spring-aop.xsd">
    16     
    17     <!-- 注册数据源:C3P0数据源 -->
    18     <bean id="myDataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    19         <property name="driverClass" value="${jdbc.driverClass}" />
    20         <property name="jdbcUrl" value="${jdbc.url}" />
    21         <property name="user" value="${jdbc.user}" />
    22         <property name="password" value="${jdbc.password}" />
    23     </bean>
    24     
    25     <!-- 注册JDBC属性文件 -->
    26     <context:property-placeholder location="classpath:jdbc.properties"/>
    27     
    28     <!-- 注册Dao -->
    29     <bean id="accountDao" class="com.tongji.dao.AccountDaoImpl">
    30         <property name="dataSource" ref="myDataSource"/>
    31     </bean>
    32     <bean id="stockDao" class="com.tongji.dao.StockDaoImpl">
    33         <property name="dataSource" ref="myDataSource"/>
    34     </bean>
    35     <!-- 注册Service -->
    36     <bean id="stockService" class="com.tongji.service.StockProcessServiceImpl">
    37         <property name="accountDao" ref="accountDao"/>
    38         <property name="stockDao" ref="stockDao"/>
    39     </bean>    
    40     
    41     <!-- 事务 -->
    42     <!-- 注册事务管理器 -->
    43     <bean id="myTxManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    44         <property name="dataSource" ref="myDataSource"/>
    45     </bean>
    46     <!-- 注册事务通知 -->
    47     <tx:advice id="txAdvice" transaction-manager="myTxManager">
    48         <tx:attributes>
    49             <!-- 指定在连接点方法上应用的事务属性 -->
    50             <tx:method name="open*" isolation="DEFAULT" propagation="REQUIRED"/>
    51             <tx:method name="buyStock" isolation="DEFAULT" propagation="REQUIRED" rollback-for="StockException"/>
    52         </tx:attributes>
    53     </tx:advice>
    54     
    55     <!-- AOP配置 -->
    56     <aop:config>
    57         <!-- 指定切入点 -->
    58         <aop:pointcut expression="execution(* *..service.*.*(..))" id="stockPointCut"/>
    59         <aop:advisor advice-ref="txAdvice" pointcut-ref="stockPointCut"/>
    60     </aop:config>
    61 </beans>
    复制代码

      总结:Spring 的事务管理,是 AOP 的应用,将事务作为切面织入到了 Service 层的业务方法中。

    转载于:https://www.cnblogs.com/niehaikuo/p/8583491.html

    展开全文
  • 抽象,就是由具体的例子范化一般的情况,抽象对计算机学科是非常重要的。以我们学习的函数为例,实际就是观察有些操作反复使用,我们将其抽象成一个功能模块,使其只写一次就可以多次调用。可以参见 ...
  • 一般情况下,需要将事务提升业务层,即 Service 层。这样做是为了能够使用事务特性来管理具体的业务。 在 Spring 中通常可以通过以下三种方式来实现对事务管理: (1)使用 Spring 事务代理工厂管理...
  • 策略模式将行为和环境隔离开来,环境角色类负责维持和查询行为类,各种类似逻辑算法都在各个具体的策略类中进行实现,由于环境和行为隔离开来,所以行为逻辑变更不会影响环境和客户端。   如果要使用策略...
  •  在写Socket通讯程序时候,为了校验传送数据包完整性,我一般会使用给数据包附加校验码 方法,具体做法就是:对要传输数据从第一个字符最后一个字符进行异或运算,最后回得到一个异或 结果...
  • http://blog.csdn.net/hnwanghb/archive/2005/03/15/319834.aspx在写Socket通讯程序时候,为了校验传送数据包完整性,我一般会使用给数据包附加校验码方法,具体做法就是: 对要传输数据从第一个字符最后一...
  • 建造者模式例子

    千次阅读 2016-12-06 16:14:04
    一、类图二、设计到的角色产品(Product)角色 由一系列部件组成,一般是一个较为复杂对象,也就是说创建对象过程比较复杂,一般会有比较多代码量。在本类图中,产品类是一个具体的类,而非抽象类。实际编程...
  • 词典的具体格式

    2008-03-12 00:13:27
    和奥普迪方第一次谈话后决定把重心完全放词典应用上了,目前电子词典有很多不尽人意地方。 目前存在问题可以这样总结一下: 1.词典格式不良好 金山词霸将意思解释在前边,12345...,例子又全部在后边...
  • 这一回我们来看一些具体的例子, 把高斯消去法练熟. 记得以前有篇课文叫卖油翁, 讲的是一个卖油的老头可以从铜钱的孔里将油倒过去, 而不粘湿钱. 别人都觉得很厉害, 问老头有什么诀窍, 老头说: 无他,唯手熟尔. 学...
  • 比如你系统中有一个任务流程,一般情况下这个任务代码逻辑、流程你都要自己来编写。实现它是没有问题。但是谁能保证逻辑编写毫无纰漏?经过无数次测试与改进,这个流程没有任何漏洞也是可以实现,但是...
  • session是存在服务器指定目录中一个全局变量了,对于一般登录是可以做到,但像淘宝购物车如果全部做session肯定是不行,我们需要把session保存数据库以方便下次调用具体操作如。 session入库操作例子 ...
  • 集中式的配置管理在应用集群中是非常常见的,一般商业公司内部都会实现一套集中...来看具体的例子: 新增三个Client,模拟真实系统的应用。 Client1作为配置管理应用: 创建config znode,设置配置的默认值: ...
  • 技术应用涉及到的四个方面问题

    千次阅读 2016-01-04 23:50:37
    作者:朱金灿来源:...下面我以一个具体的例子来解释这四个方面的问题。比如家电制造商的需求调查人员通过调查,发现用户的需求是想吃上热饭,于是就定义了一个问题:通过制造什么家电能够满足用户吃上热
  • 简单例子说明快速排序算法

    千次阅读 2016-09-27 21:17:24
    快速排序快速排序简单说就是选择一个基准,将比基准大数放在一边,小数放另一边。对这个数两边再递归上述方法...69具体快速排序规则一般如下: 从右边开始查找比66小数,找到时候先等一下,再从左边开
  • 今天这第八个例子原理上挺简单,但是他写代码实在吓人,可以说后面这些代码越来越吓人,但是说实话我又不是做软件,八成也用不。 Gtest 小技巧 - 9:"联合"参数化     前面两节为了让程序方便,我们在参数...
  • 策略模式原理及例子代码

    千次阅读 2011-11-03 21:04:20
    策略模式将行为和环境隔离开来,环境角色类负责维持和查询行为类,各种类似逻辑算法都在各个具体的策略类中进行实现,由于环境和行为隔离开来,所以行为逻辑变更不会影响环境和客户端。 如果要使用策略类,...
  • 更加一般的情况是,在指定空间区域绘制一个函数的图像——而不是仅仅绘制这个不等式区域。这一点,Mathematcia里面的RegionFunction选项可以很方便做到。 1. MATLAB实现任意不等式区域(空间)可视化 那么MATLAB...
  • 一般我们了项目上线时候都会这么干,基于docker环境,编写好Dockerfile文件,打包我们应用程序给运维,运维不需要安装任何软件,只要有docker环境,直接一个命令直接构建项目便可,下面是详细手把手具体...
  • 句,这里我们将其放private 里,因为一般的函数都放在public 里,而变量 都放在private 里。 #ifndef WIDGET_H #define WIDGET_H #include #include "mydlg.h" //包含头文件 namespace Ui { class Widget; } ...
  • 设计模式(Design pattern)代表了最佳...设计模式使用场景:设计模式提供了一个标准术语系统,且具体到特定情景。相当于约定好模式,这样交流起来很方便。例如,单例设计模式意味着使用单个对象,这样所有...
  • 具体来说,调用约定一般规定了参数、返回值、返回地址等放置位置(寄存器、栈或存储器等)如何将调用子过程准备工作与恢复现场工作划分调用者(Caller)与被调用者(Callee)身上调用约定虽然叫“Convention...
  • 理论辅助: ...还是那个基调,不喜欢纯理论东西,喜欢使用例子来讲诉理论,在算法系列总结:动态规划(解公司外包成本问题) 那一节里面 我们举得是经典0-1背包问题,在回溯算法里面也有一些很经典

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 600
精华内容 240
关键字:

具体到一般的例子