在spring中如何配代码的事务管理
Spring+Hibernate+Atomikos配置JTA事务
Spring+Hibernate+Atomikos配置JTA事务例子1.依赖jar包2.配置文件(1)数据源、JTA事务配置文件src/applicationContext-common.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><!--chh用户datasource --><bean id="oracleDataSource"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh</prop><prop key="password">chh</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><!--chh1用户datasource --><bean id="oracleDataSource1"class="com.atomikos.jdbc.AtomikosDataSourceBean"><property name="uniqueResourceName"><value>chh1</value></property><propertyname="xaDataSourceClassName"><value>oracle.jdbc.xa.client.OracleXADat aSource</value></property><property name="xaProperties"><props><prop key="user">chh1</prop><prop key="password">chh1</prop><prop key="URL">jdbc:oracle:thin:@127.0.0.1:1521:chh</prop></props></property><property name="poolSize"><value>1</value></property><property name="borrowConnectionTimeout"><value>60</value></property> </bean><!--为hibernate-jtatest1.cfg.xml注入chh用户datasource--><bean id="chhSessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"><property name="configLocation"value="classpath:hibernate-jtatest1.cfg.xml" /><property name="dataSource" ref="oracleDataSource"></property></bean><!--为hibernate-jtatest2.cfg.xml注入chh1用户datasource--><bean id="chh1SessionFactory"class="org.springframework.orm.hibernate3.LocalSessionFactoryBean"> <property name="configLocation"value="classpath:hibernate-jtatest2.cfg.xml" /><property name="dataSource" ref="oracleDataSource1"></property></bean><!-- atomikos事务管理器 --><bean id="atomikosTransactionManager"class="erTransactionManager"init-method="init" destroy-method="close"><property name="forceShutdown"><value>true</value></property></bean><!-- atomikos事务的实现 --><bean id="atomikosUserTransaction"class="erTransactionImp"><property name="transactionTimeout"><value>300</value></property> </bean><!-- atomiko事务管理器封装成Spring事务管理器--><bean id="springTransactionManager"class="org.springframework.transaction.jta.JtaTransactionManager"><property name="transactionManager"><refbean="atomikosTransactionManager" /></property><property name="userTransaction"><ref bean="atomikosUserTransaction" /></property><property name="allowCustomIsolationLevels" value="true"/></bean><!-- 通知配置 --><tx:advice id="txAdvice"transaction-manager="springTransactionManager"><tx:attributes><tx:method name="delete*" rollback-for="Exception"/><tx:method name="save*" rollback-for="Exception"/><tx:method name="update*" rollback-for="Exception"/><tx:method name="*" read-only="true" rollback-for="Exception"/></tx:attributes></tx:advice><!-- 事务切面配置 --><aop:config><aop:pointcut id="point"expression=" execution(* com.zte.jta.serviceImp.*.*(..))" /><!-- 指定使用jta事务的类、方法 --><aop:advisor advice-ref="txAdvice" pointcut-ref="point" /></aop:config></beans>(2) 业务配置文件src/applicationContext-service.xml<?xml version="1.0" encoding="GBK"?><beans xmlns="/schema/beans"xmlns:xsi="/2001/XMLSchema-instance"xmlns:context="/schema/context"xmlns:tx="/schema/tx"xmlns:aop="/schema/aop"xsi:schemaLocation="/schema/beans /schema/beans/spring-beans-2.5.xsd/schema/context/schema/context/spring-context-2.5.xsd /schema/tx/schema/tx/spring-tx-2.5.xsd/schema/aop/schema/aop/spring-aop-2.5.xsd"><bean id="biz" class="impl"><property name="productDao" ref="productDao" /><property name="userDao" ref="userDao" /></bean><bean id="userDao" class="erDaoimpl"><property name="sessionFactory" ref="chhSessionFactory" /></bean><bean id="productDao" class="com.zte.jta.daoImp.ProductDaoimpl"><property name="sessionFactory" ref="chh1SessionFactory" /></bean></beans>(3)数据源1 hibernate 配置文件src/hibernate-jtatest1.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Users.hbm.xml" /></session-factory></hibernate-configuration>(3) 数据源2 hibernate 配置文件src/hibernate-jtatest2.cfg.xml<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""/hibernate-configuration-3.0.dtd"><hibernate-configuration><session-factory><propertyname="hibernate.dialect">org.hibernate.dialect.Oracle10gDialect</prop erty><property name="show_sql">true</property><mapping resource="com/zte/jta/test/Product.hbm.xml" /></session-factory></hibernate-configuration>(4)对象映射关系数据配置文件src/com/zte/jta/test/Product.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="com.zte.jta.test.Product" table="product" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_product</param></generator></id><property name="price" type="ng.Float"><column name="price" precision="53" scale="0" not-null="true" /></property></class></hibernate-mapping>(5)对象映射关系数据配置文件src/com/zte/jta/testUsers.hbm.xml<?xml version="1.0" encoding="UTF-8" ?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"><hibernate-mapping><class name="ers" table="tusers" ><id name="id" type="ng.Integer"><column name="id" /><generator class="sequence" ><param name="sequence">SEQ_tusers</param></generator></id><property name="name" type="ng.String"><column name="name" length="100" not-null="true" /> </property></class></hibernate-mapping>3.Java代码(1)src/com/zte/jta/dao/ProductDao.javapackage com.zte.jta.dao;import com.zte.jta.test.Product;public interface ProductDao {public abstract void save(Product p);}(2)src/com/zte/jta/dao/UserDao.javapackage com.zte.jta.dao;import ers;public interface UserDao {public abstract void save(Users u);}(3)src/com/zte/jta/daoImp/ProductDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import com.zte.jta.dao.ProductDao;import com.zte.jta.test.Product;public class ProductDaoimpl extends HibernateDaoSupport implements ProductDao {public void save(Product p){this.getHibernateTemplate().save(p);}}(4)src/com/zte/jta/daoImp/UserDaoimpl.javapackage com.zte.jta.daoImp;importorg.springframework.orm.hibernate3.support.HibernateDaoSupport;import erDao;import ers;public class UserDaoimpl extends HibernateDaoSupport implements UserDao {public void save(Users u){this.getHibernateTemplate().save(u);}}(5)src/com/zte/jta/service/Biz.javapackage com.zte.jta.service;import com.zte.jta.test.Product;import ers;public interface Biz {public void save(Product p, Users u);}(6)src/com/zte/jta/serviceImp/Bizimpl.javapackage com.zte.jta.serviceImp;import com.zte.jta.dao.ProductDao;import erDao;import ;import com.zte.jta.test.Product;import ers;public class Bizimpl implements Biz {private ProductDao productDao = null;private UserDao userDao = null;public void save(Product p, Users u) {productDao.save(p);userDao.save(u);}public void setProductDao(ProductDao productDao) {this.productDao = productDao;}public void setUserDao(UserDao userDao) {erDao = userDao;}}4.数据库建对象create user chh identified by chh;create user chh identified by chh1;grant dba,resource,connect to chh;grant dba,resource,connect to chh1;grant select on sys.dba_pending_transactions to chh;grant select on sys.pending_trans$to chh;grant select on sys.dba_2pc_pending to chh;grant execute on sys.dbms_system to chh;grant select on sys.dba_pending_transactions to chh1; grant select on sys.pending_trans$to chh1;grant select on sys.dba_2pc_pending to chh1;grant execute on sys.dbms_system to chh1;create sequence chh.SEQ_tusersminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create sequence chh1.SEQ_productminvalue 1maxvalue 10000000000000000start with 1increment by 1cache 20order;create table chh.TUSERS(ID INTEGER not null,NAME VARCHAR2(50)not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table TUSERSadd primary key(ID)using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);create table CHH1.PRODUCT (ID INTEGER not null, PRICE NUMBER not null)tablespace MAPpctfree 10initrans 1maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);alter table CHH1.PRODUCT add primary key(ID) using indextablespace MAPpctfree 10initrans 2maxtrans 255storage(initial 128Knext 128Kminextents 1maxextents unlimitedpctincrease 0);5.测试方法public static void main(String[] args) {ApplicationContext context = new ClassPathXmlApplicationContext(new String[]{"applicationContext-common.xml","applicationContext-service.xml"});BeanFactory bf = context;Biz biz = (Biz) bf.getBean("biz");Product p = new Product();p.setPrice(10f);Users u = new Users();u.setName(null); //非空字段插入一个空试试，再给个值试试 "aaa"biz.save(p, u);}。
datasourcetransactionmanager用法
datasourcetransactionmanager用法DataSourcetransactionmanager 是Spring 框架中用于管理数据库事务的一种重要的机制。
通过DataSourceTransactionManager，开发人员可以在Spring 应用中使用声明式事务进行数据库操作。
在本文中，我们将详细介绍DataSourceTransactionManager 的用法，并逐步回答相关问题。
第一步：导入依赖在使用DataSourceTransactionManager 之前，首先需要在项目的构建配置文件（如pom.xml）中添加相应的依赖。
在Spring 中，DataSourceTransactionManager 是由Spring JDBC 模块提供的，因此我们需要添加相应的Spring JDBC 依赖。
xml<dependency><groupId>org.springframework</groupId><artifactId>spring-jdbc</artifactId><version>5.3.10</version></dependency>第二步：配置数据源DataSourceTransactionManager 需要一个有效的数据源来管理事务。
在Spring 应用中，数据源可以通过Spring 的配置文件（如applicationContext.xml）进行配置。
例如，我们可以使用基于连接池的数据源，如Apache Commons DBCP 或HikariCP。
xml<bean id="dataSource"class="org.apachemons.dbcp2.BasicDataSource"><property name="driverClassName" value="com.mysql.jdbc.Driver" /><property name="url"value="jdbc:mysql:localhost:3306/mydatabase" /><property name="username" value="username" /><property name="password" value="password" /></bean>第三步：配置事务管理器配置事务管理器是使用DataSourceTransactionManager 的关键步骤。
transactiontemplate异步的使用写法
TransactionTemplate是 Spring 框架中用于简化事务管理的类。
要使用TransactionTemplate执行异步操作，你需要结合@Async注解和 Spring 的任务调度功能。
1.添加依赖: 首先，确保你的项目中包含了 Spring 的任务调度依赖。
2.配置TransactionTemplate: 在 Spring 配置中，定义一个
TransactionTemplate bean。
3.创建异步事务方法: 使用@Async注解标记一个方法，并在方法内部使用
TransactionTemplate。
4.启动事务: 在需要的地方调用异步事务方法。
由于它是异步的，所以调用
后方法会立即返回。
事务将在后台执行。
5.启用异步支持: 你还需要在 Spring 的主配置类上添加@EnableAsync注
解来启用异步支持。
6.异常处理: 由于异步事务是在单独的线程中执行的，因此需要确保正确处
理任何抛出的异常，并考虑如何将它们传递回调用线程。
7.注意点: 使用异步事务时，需要确保你了解事务的隔离级别和传播行为，
以确保数据的一致性和完整性。
Spring事务配置的五种方式
Spring事务原理统观spring事务，围绕着两个核心PlatformTransactionManager和TransactionStatusspring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。
一般事务定义步骤：TransactionDefinition td = new TransactionDefinition();TransactionStatus ts = transactionManager.getTransaction(td);try{ //do sthmit(ts);}catch(Exception e){transactionManager.rollback(ts);}spring提供的事务管理可以分为两类：编程式的和声明式的。
编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。
编程式主要使用transactionTemplate。
省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.void add(){transactionTemplate.execute( new TransactionCallback(){pulic Object doInTransaction(TransactionStatus ts){ //do sth}}}声明式：使用TransactionProxyFactoryBean:<bean id="userManager" class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"><property name="transactionManager"><ref bean="transactionManager"/></property><property name="target"><ref local="userManagerTarget"/></property><property name="transactionAttributes"><props><prop key="insert*">PROPAGATION_REQUIRED</prop><prop key="update*">PROPAGATION_REQUIRED</prop><prop key="*">PROPAGATION_REQUIRED,readOnly</prop></props></property></bean>围绕Poxy的动态代理能够自动的提交和回滚事务org.springframework.transaction.interceptor.TransactionProxyFactoryBeanPROPAGATION_REQUIRED--支持当前事务，如果当前没有事务，就新建一个事务。
详解SpringBoot中JdbcTemplate的事务控制
详解SpringBoot中JdbcTemplate的事务控制⽬录前⾔原⽣Jdbc的事务控制Spring的声明式事务控制尝试JdbcTemplate的事务控制TransactionTemplate的编程式事务控制前⾔JdbcTemplate是spring-jdbc提供的数据库核⼼操作类，那对JdbcTemplate进⾏事务控制呢？我的环境：spring-boot-2.1.3，druid-1.1.3。
原⽣Jdbc的事务控制即，批处理+⾃动提交的控制⽅式，public static void demo(String[] args) throws SQLException, ClassNotFoundException {String url = "jdbc:mysql://10.1.4.16:3306/szhtest";String username = "ababab";String password = "123456";String sql1 = "insert xx";String sql2 = "insert xx";Class.forName("com.mysql.jdbc.Driver");Connection conn = DriverManager.getConnection(url, username, password);Statement statement = conn.createStatement();// 获取到原本的⾃动提交状态boolean ac = conn.getAutoCommit();// 批处理多条sql操作statement.addBatch(sql1);statement.addBatch(sql2);// 关闭⾃动提交conn.setAutoCommit(false);try {// 提交批处理statement.executeBatch();// 若批处理⽆异常，则准备⼿动commitmit();} catch (Exception e) {e.printStackTrace();// 批处理抛异常，则rollbacktry {conn.rollback();} catch (SQLException ex) {ex.printStackTrace();}} finally {// 恢复到原本的⾃动提交状态conn.setAutoCommit(ac);if (statement != null) {try {statement.close();} catch (SQLException e) {e.printStackTrace();}}if (conn != null) {try {conn.close();} catch (SQLException e) {e.printStackTrace();}}}}Spring的声明式事务控制Bean的类或⽅法上加@Transactional，事务控制粒度较⼤，只能控制在⽅法级别，不能控制到代码粒度级别。
java事务实现方式
java事务实现方式
在Java中，事务是一组操作单元，它们被当作一个单一的工作单元来执行。
事务管理是确保数据库操作的一致性和可靠性的重要组成部分。
Java中常见的事务实现方式包括：
1、JDBC事务：
使用java.sql.Connection对象，通过调用setAutoCommit(false)来启用手动事务管理。
使用commit()提交事务或rollback()回滚事务。
2、Spring声明式事务管理：
使用@Transactional注解来声明事务。
配置事务管理器（ 如DataSourceTransactionManager）。
3、使用Spring编程式事务管理：
使用TransactionTemplate来编程式管理事务。
4、JTA事务 Java（Transaction（API）：
使用erTransaction接口。
通常用于分布式事务，涉及多个数据源。
这些是一些常见的Java事务实现方式，选择适合你应用场景的方式取决于你的需求和技术栈。
SpringBoot事务注解详解
SpringBoot事务注解详解SpringBoot事务注解详解@Transactionalspring 事务注解1.简单开启事务管理@EnableTransactionManagement // 启注解事务管理，等同于xml配置⽅式的 <tx:annotation-driven />2.事务注解详解默认遇到throw new RuntimeException(“…”);会回滚需要捕获的throw new Exception(“…”);不会回滚指定回滚@Transactional(rollbackFor=Exception.class)public void methodName() {// 不会回滚throw new Exception("...");}指定不回滚@Transactional(noRollbackFor=Exception.class)public ItimDaoImpl getItemDaoImpl() {// 会回滚throw new RuntimeException("注释");}如果有事务,那么加⼊事务,没有的话新建⼀个(不写的情况下)@Transactional(propagation=Propagation.REQUIRED)容器不为这个⽅法开启事务@Transactional(propagation=Propagation.NOT_SUPPORTED)readOnly=true只读,不能更新,删除@Transactional (propagation = Propagation.REQUIRED,readOnly=true)设置超时时间@Transactional (propagation = Propagation.REQUIRED,timeout=30)设置数据库隔离级别@Transactional (propagation = Propagation.REQUIRED,isolation=Isolation.DEFAULT)3.指定事务管理器spring Boot 使⽤事务⾮常简单，⾸先使⽤注解 @EnableTransactionManagement 开启事务⽀持后，然后在访问数据库的Service⽅法上添加注解 @Transactional 便可。
transactional 中添加transactiontemplate
transactional 中添加transactiontemplate transactional是Spring框架中的一个注解，用于为方法添加事务支持。
在使用transactional注解时，可以使用TransactionTemplate来更加灵活地管理事务的细节。
本文将详细介绍在transactional中添加TransactionTemplate的步骤和原理。
一、什么是transactional注解和TransactionTemplate？1. transactional注解transactional是Spring框架中的一个注解，用于为方法添加事务支持。
在使用transactional注解时，可以指定事务的传播行为、隔离级别、回滚规则等细节。
2. TransactionTemplateTransactionTemplate是Spring框架中的一个类，用于编程式地管理事务。
通过TransactionTemplate，可以更加灵活地控制事务的开始、提交和回滚操作。
二、为什么要在transactional中添加TransactionTemplate？1. 灵活控制事务事务的传播行为、隔离级别、回滚规则通常是在transactional注解中指定的。
但是有些情况下，我们可能需要根据特定的业务逻辑来动态地控制事务的开始、提交和回滚操作。
这时，就可以使用TransactionTemplate来实现更加灵活的事务管理。
2. 提高代码可读性通过在transactional注解中添加TransactionTemplate，可以将事务管理的细节从业务逻辑中分离出来，使代码更加清晰，易于阅读和维护。
三、在transactional中添加TransactionTemplate的步骤1. 导入依赖在pom.xml文件中添加Spring事务支持的依赖：xml<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId> </dependency>2. 添加EnableTransactionManagement注解在SpringBootApplication类上添加EnableTransactionManagement注解，开启Spring事务管理的支持：javaSpringBootApplicationEnableTransactionManagementpublic class Application {public static void main(String[] args) {SpringApplication.run(Application.class, args);}}3. 在方法上添加transactional注解在需要添加事务支持的方法上添加Transactional注解，并指定事务的传播行为、隔离级别和回滚规则：javaServicepublic class UserService {Autowiredprivate UserRepository userRepository;Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, rollbackFor = Exception.class) public void updateUser(User user) {更新用户信息的业务逻辑}}4. 使用TransactionTemplate来控制事务在需要动态控制事务的方法内部，可以使用TransactionTemplate来开启、提交和回滚事务：javaServicepublic class UserService {Autowiredprivate UserRepository userRepository;Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT, rollbackFor = Exception.class) public void updateUser(User user) {开始事务TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);transactionTemplate.setPropagationBehavior(TransactionDefinition .PROPAGATION_REQUIRED);TransactionStatus status = transactionTemplate.getTransactionManager().getTransaction(transactionTemplate);try {更新用户信息的业务逻辑userRepository.save(user);提交事务transactionTemplate.getTransactionManager()mit(status);} catch (Exception e) {回滚事务transactionTemplate.getTransactionManager().rollback(status);throw e;}}}四、TransactionTemplate的原理1. 提供事务功能的beanTransactionTemplate提供了事务管理的功能，通过与事务管理器（transactionManager）的结合使用，实现了管理事务的开始、提交和回滚操作。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
在spring中如何配代码的事务管理
在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：org.springframework.web.context.ContextLoaderListener ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。
缺省情况下，它会在WEB-INF/applicationContext.xml文件找Spring的配置。
你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring 配置文件的位置。
示例
使用”org.springframework.jdbc.datasource.DriverManagerDataSou rce”数据源来配置数据库驱动。
示例如下：org.hsqldb.jdbcDriver jdbc:hsqldb:db/appfuse sa
spring提供了几个关于事务处理的类：TransactionDefinition //事务属性定义TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransac
在context中定义DataSource，创建SessionFactoy，设置参
数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。
在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter 或OpenSessionInViewIntercepto
一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C 的实例，但这种方法显然两者的依赖（Dependency）太大了。
而IoC 的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的。