精华内容
下载资源
问答
  • Spring之事物抽象

    2014-10-18 15:59:58
    Spring事物抽象的关键是事物策略的概念。

    Spring事物抽象的关键是事物策略的概念。事物策略由org.springframework.transaction.PlatformTransactionManager接口定义。


    public interface PlatformTransactionManager {
    
        TransactionStatus getTransaction(
                TransactionDefinition definition) throws TransactionException;
    
        void commit(TransactionStatus status) throws TransactionException;
    
        void rollback(TransactionStatus status) throws TransactionException;
    }



    这是一个主要的业务提供器接口(SPI),虽然可以在你的应用程序代码中使用程序化编程。因为PlatformTransactionManager是一个接口,其可以很容器根据需要仿制或存根。其没有绑定到一个查找策略,比如JNDI。PlatformTransactionManager的实现类就如同SpringIoC容器中的其他对象或者bean一样。这使得Spring框架事物抽象即使在与JTA使用时也同样受益。事物代码将比直接使用JTA更加容易测试。


    继续遵循Spring的优良传统,TransactionException异常可以被任何PlatformTransactionManager接口的方法(非检查型,继承了java.lang.runnable接口)的抛出。事物的基础设施故障几乎总是致命的。在从事物失败中确实恢复中的应用程序代码中,应用程序开发者可以仍旧选择抓取和处理TransactionException。突出点是开发者不必强制这样处理这些异常。


    getTransaction(。。。)方法返回一个TransactionStatus对象,这取决于TransactionDefinition参数。返回的TransactionStatus可能表示一个新的事物,或者代表一个存在的事物,如果一个匹配的事物存在于当前调用栈中。在后面例子中显示的,如果使用JavaEE事物上下文,TransactionStatus与执行线程关联。


    TransactionDefinition接口指定了如下设置:

    • Isolation(隔离性):这个事物与其他事物工作的隔离程序。例如,这个事物是否可以看见其他事物提交的写操作?
    • Propagation(传播性):一般地,在一个事物范围内运行的所有代码将在这个事物中运行。然而,你知道当你一个事物上下文已经存在时,执行事物方法的事件中要指定行为。例如,代码可以继续运行在存在的事物中(一般情况),或者存在的事物可以暂停并且创建一个新的事物。Spring提供了与EJB CMT相似的全部事物传播概念
    • Timeout(超时):事物将运行多久,在超时和由指定底层事物回滚前。
    • Read-only状态:当你的代码仅读而不是修改数据,可以使用只读事物。这个事物在一些情况下是一个很有用的选项,比如当你使用Hibernate的时候。

    这些设置反映了标准饿事物概念。如果必要,还涉及到讨论事物隔离级别的资源和其他核心事物概念。理解这些概念对于使用Spring框架或者其他事物管理解决方案是很重要的。


    TransactionStatus接口为事物代码控制事物执行和查询事物状态提供了一个简单的方式。概念是相似的,如同事物APIs一样。

    public interface TransactionStatus extends SavepointManager {
    
        boolean isNewTransaction();
    
        boolean hasSavepoint();
    
        void setRollbackOnly();
    
        boolean isRollbackOnly();
    
        void flush();
    
        boolean isCompleted();
    
    }

    不管在Spring中选择声明式或者编程式事物管理,定义正确的PlatformTransactionManager实现类是绝对重要的。一般通过依赖注入定义这个实现。


    PlatformTransactionManager实现通常要求了解其工作的环境:JDBC,JTA,Hibernate等等。下面的例子显示了如何定义一个本地的PlatformTransactionManager实现(这个例子的工作环境是什么都没有的JDBC)。


    你定义一个JDBC的DataSource:

    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driverClassName}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
    </bean>

    关联的PlatformTransactionManager bean定义稍后将有一个DataSource的引用。将如下所示:

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>

    如果在JavaEE容器章使用JTA,稍后你使用一个容器DataSource,通过JNDI获取,与Spring的JtaTransactionManager连接。下面就是JTA和JNDI查找的形式:

    <?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:jee="http://www.springframework.org/schema/jee"
        xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/jee
            http://www.springframework.org/schema/jee/spring-jee.xsd">
    
        <jee:jndi-lookup id="dataSource" jndi-name="jdbc/jpetstore"/>
    
        <bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager" />
    
        <!-- other <bean/> definitions here -->
    
    </beans>



    JtaTransactionManager不需要知道DataSource,或者其他指定的资源,因为其使用容器的全局事物管理机制。


    注意:上述的dataSource bean定义使用来自jee命名空间的<jndi-lookup/>标签。


    你也可以很容器的使用Hibernate的本地事物,如同下面例子显示的那样。在这个例子中,你需要定义一个Hibernate的LocalSessionFactoryBean,这样你的应用程序代码使用它获取Hibernate Session实例。


    DataSource bean定义与前面显示的本地JDBC例子相同,那么在下面的例子中将不再显示。


    注意:如果DataSource,被任何非JTA事物管理器使用的,通过JNDI查找并且由JavaEE容器管理。那么其应该是非事物的,因为Spring框架,而不是Java EE容器将管理这个事物。


    这个例子中的Manager bean是HibernateTransactionManager类型的。如同DataSourceTransactionManager一样,需要一个DataSource的引用,HibernateTransactionManager 需要一个SessionFactory的引用。

    <bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="mappingResources">
            <list>
                <value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=${hibernate.dialect}
            </value>
        </property>
    </bean>
    
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>

    如果你使用Hibernate和Java EE管理的JTA事物,那么你应该简单地使用前面JTA例子针对JDBC的相同的JtaTransactionManager。

    <bean id="txManager" class="org.springframework.transaction.jta.JtaTransactionManager"/>

    注意:如果你使用JTA,那么你的事物管理器定义将查找你使用的所有数据访问技术,不管是JDBC,Hibernate JPA或者任何其他支持的技术。这是基于JTA事物是全局事物的事实,其将查找所有的事物资源。


    在所有的这些例子中,应用程序代码不需要改变。你可以改变的是事物如何仅仅通过改变配置来进行管理,即使这些改变意味着全本地向全局事物变化,反之亦然。




    
    
    展开全文
  • 抽象事物理解

    千次阅读 2013-08-10 11:08:31
    理解抽象事物的好办法就是用实例去代换。 就好比我理解一个一个概念或者公式的时候一样,把那些抽象的符号,拗口的条件,用实际的数值,现实的事物取代,这样 结果对我们是已知的,那么公式的结果定理的结论,我们...

    理解抽象事物的好办法就是用实例去代换。

    就好比我理解一个一个概念或者公式的时候一样,把那些抽象的符号,拗口的条件,用实际的数值,现实的事物取代,这样

    结果对我们是已知的,那么公式的结果和定理的结论,我们就可以验证了。

    尽管这个不足以证明问题的正确性,但是对于问题的不正确性是足以说明的。


    同样的方法也适合我们理解抽象的代码(我这里不是指写的乱七八糟的代码,而是指为了增强代码的重用性和可维护性而采用的

    特定模式):

    首先、不要死命看抽象类和借口;

    而是应该抓住关联,去看实际实现这个抽象类或者接口的实现类,在哪里你将会看到很多的已知条件,足以满足理解的需求。

    也会对整体的业务理解有帮助。


    无论什么业务都是特性的,它对应的就是我们具体类;

    而,业务是无穷无尽的,我们做软件开发的,不可能每个业务去写一个类;

    所以,我们想出了抽象,想出了提取公共部分,想起了通用。


    然而,我们做完了这些还不够,因为我们除了要满足业务需求,我们还要考虑可测试性,可发布性,可维护性,

    所有这些都会影响我们对系统的设计,这些设计可以大到整个系统的架构设计,小到每个类的设计,贯穿始终。

    展开全文
  • 类是抽象的,并不是具体的指某一事物,而是泛指某一类事物。 @class myClass;  myClass *stu; :是方法名的一部分 oc中定义的方法都是公有方法 所有的object-c的对象都是在堆上创建的

    类是抽象的,并不是具体的指某一事物,而是泛指某一类事物。


    @class myClass;


       myClass *stu;

    :是方法名的一部分

    oc中定义的方法都是公有方法


    所有的objectc的对象都是在堆上创建的


    展开全文
  • 从客观事物抽象出类的例子

    千次阅读 2018-05-11 09:23:02
    写一个程序,输入矩形的宽高,输出面积周长·矩形的属性-宽高 ·两个变量,分别代表宽高·对矩形的操作 ·设置宽高 ·计算面积 ·计算周长class Rectangle{ public: int w, h; void Init(int w_, ...
    写一个程序,输入矩形的宽和高,输出面积和周长
    
    ·矩形的属性-宽和高
        ·两个变量,分别代表宽和高
    ·对矩形的操作
        ·设置宽和高
        ·计算面积
        ·计算周长
    class Rectangle{
        public:
            int w, h;
        void Init(int w_, int h_){
            w = w_;
            h = h_;
        }
        int Area(){
            return w * h;
        };
        int Perimeter(){
            return 2 * (w + h);
        }
    };
    
    int main(){
        int w, h;
        Rectangle r;//r是一个对象
        cin>>w>>h;
        r.Init(w, h);
        cout<<r.Area()<<endl<<r.Perimeter();
        return 0;
    }

    ·类定义的变量-->类的实例-->“对象”
    ·对象的内存空间
        ·对象的大小 = 所有成员变量的大小之和
        ·E.g. Rectangle类的对象,sizeof(Rectangle) = 8
    ·每个对象各有自己的存储空间
        ·一个对象的某个成员变量被改变,不会影响到其他的对象
    ·对象间的运算
        ·对象之间可以用 = 进行赋值
        ·不能用 == != > < >= <= 进行比较

            ·除非这些运算符经过了"重载"

    用法1:对象名.成员名

        Rectangle r1, r2;
        r1.w = 5;
        r2.Init(3, 4);

    用法2:指针->成员名

        Rectangle r1, r2;
        Rectangle *p1 = &r1;
        Rectangle *p2 = &r2;
        p1->w = 5;
        p2->Init(3, 4);//Init作用在p2指向的对象上
    用法3:引用名.成员名
        Rectangle r2;
        Rectangle & rr = r2;
        rr.w = 5;
        rr.Init(3,4);//rr的值变了,r2的值也变

    另一种输出结果的方式:

        void PrintRectangle(Rectangle &r){
            cout<<r.Area()<<","<<r.Perimeter();
        }
        Rectangle r3;
        r3.Init(3, 4);
        PrintRectangle(r3);
    类的成员函数的另一种写法

    ·成员函数体和类的定义分开写

        class Rectangle{
            public:
                int w, h;
                int Area();//成员函数仅在此声明
                int Perimeter();
                void Init(int w_, int h_);
        }
        int Rectangle::Area(){
            return w * h;
        }
        int Rectangle::Perimeter(){
            return 2 * (w + h);
        }
        void Rectangle::Init(int w_, int h_){
            w = w_;
            h = h_;
        }

    调用通过:对象/对象的指针/对象的引用


    感谢北大!!

    展开全文
  • 在编程语言中有很多都来自对现实事物抽象,如java语言中容器这个概念。在现实生活中容器是用来盛放物品的,java中的容器也是用来储存其他数据的。到超市去买水果就要先用袋子把水果装起来,然后去付账。这个袋子...
  • 接口可以继承接口。 抽象类并不能继承接口,但可以实现接口。 抽象类可以继承具体类...抽象类在面向对象中是被用来描述现实中的抽象事物, 抽象类没有对象概念所以不能被实例化. 但可以定义属性方法, 其中属性方.
  • 接口和抽象类的区别

    万次阅读 多人点赞 2018-08-12 21:38:36
    接口和抽象类有什么区别 你选择使用接口和抽象类的依据是什么? 接口和抽象类的概念不一样。接口是对动作的抽象抽象类是对根源的抽象抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。...
  • 接口和抽象区别

    2019-08-15 09:35:57
    接口和抽象类的区别: 语法: 1>抽象类使用abstract,接口使用interface 2>抽象类中可以包含抽象方法,也可以包含非抽象方法,接口中只能包含抽象方法静态常量,jdk1.8之后接口可以包含静态方法...
  • Abstraction 定义抽象的接口 该接口包含实现具体行为、具体特征...抽象接口Abstraction的子类,依旧是一个抽象事物名 Implementor 定义具体行为、具体特征的应用接口 ConcreteImplementor 实现Implementor接口
  • 抽象接口的区别以及抽象接口的使用场景

    千次阅读 多人点赞 2019-05-30 18:15:44
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法:使用...
  • 接口和抽象类的使用区别?

    万次阅读 2019-06-18 14:48:00
    抽象类是事物的本质 太监案例: /** * Human 抽象类 */ abstract class Human{ //吃饭 abstract fun eat() //睡觉 abstract fun sleep() } /** * IMan 接口 */ interface IMan { //生育 ...
  • Java中抽象接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。...抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为...
  • 抽象接口的区别及使用场景

    千次阅读 多人点赞 2018-07-09 10:22:53
    抽象接口的区别及使用场景 1.1 抽象类 1.2 接口 1.3 抽象接口的区别 1.3.1 语法层面上的区别 1.3.2 设计层面上的区别 1.4 什么时候使用抽象接口 抽象接口的区别及使用场景 1.1 抽象类 在...
  • Java中接口和抽象类的区别

    千次阅读 2019-04-29 19:51:53
    java中接口和抽象类的区别 ...
  • 抽象接口的区别

    2017-03-18 20:48:29
    抽象类:抽象类是一种有抽象方法的类,抽象方法只有声明,没有具体的实现,同时抽象类也可以有默认的方法实现。(即若一个类中有用abstract关键字修饰的抽象方法,则这个类就是抽象类,但是抽象类中可以有非抽象方法...
  • 所谓抽象就是对同一类事物的相同特性的提取
  • 抽象和接口的区别

    千次阅读 2019-05-11 11:28:06
    抽象类中必须包含至少一个抽象方法,并且所有抽象方法不能有具体的实现,而应在它们的子类中实现所有的抽象方法(要有方法体)。 接口类似于类,但接口的成员没有执行体,它只是方法、属性、事件索引符的组合...
  • 接口和抽象类有什么区别

    万次阅读 多人点赞 2008-07-31 12:54:00
    接口和抽象类有什么区别 你选择使用接口和抽象类的依据是什么? 接口和抽象类的概念不一样。接口是对动作的抽象抽象类是对根源的抽象抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。...
  • 面试 | 接口和抽象类的区别

    千次阅读 2019-03-06 21:00:09
    虽然面试的时候可能没有那么的时间全部说完,但我觉得概念设计目的应该要说清楚;因为从这两点就能看出你对两者的理解深度。 1.概念的不同 接口:是对行为的抽象,是抽象方法的集合。实现接口的类必须遵循契约模式...
  • 抽象

    2018-03-09 22:19:56
    抽象类abstract关键字,当类中存在抽象 那这个类也需抽象抽象类:在描述事物时,没有足够的信息描述一个事物,该事物就称为抽象事物。抽象类一定是父类,因为不断抽取而来的抽象类中有构造函数,虽然不能给自己的对象...
  • C#抽象方法和抽象

    2017-03-26 16:36:49
    而抽象方法则说明这种抽象事物有某种特性,但是当抽象事物具体到某一种实物的实物,不同的个体的这种特性又不同,如狗猫的叫声不同。因此,把狗猫叫的这种动作定义为一种抽象方法。 抽象类定义:在类的前面加上...
  • 抽象类:共性的抽取 该体系的共性内容 4) 抽象类只能被继承,一个具体类继承一个抽象类,必须实现所有抽象方法 C:抽象类不能实例化,要...接口的区别:体系的扩展内容 (1)有些功能未必是某个事物体系本身就具备的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 134,423
精华内容 53,769
关键字:

具体事物和抽象事物的区别