Spring_day03 Demo代码

原创

武大保安 2022-09-19 15:54:55 博主文章分类：后端框架-SSH ©著作权

文章标签 spring java xml 文章分类 虚拟化云计算

©著作权归作者所有：来自51CTO博客作者武大保安的原创作品，请联系作者获取转载授权，否则将追究法律责任

本博客为这篇博客的辅助博客，主要是其中自己写的一些Demo.java代码

applicationContext.xml

Demo1.java

Spring框架的JDBC模板技术

applicationContext.xml2

Demo1.java

Demo1_1.java

Spring框架的事务管理

搭建事务管理转账案例的环境和自己编码处理事务

AccountDao.java

AccountDaoImpl.java

AccountService.java

AccountServiceImpl.java

applicationContext.xml3

Demo1.java3

Spring框架的声明式事务管理，通过配置文件来完成事务管理(AOP思想)

AspectJ的XML方式

AccountServiceImpl.java4

applicationContext2.xml4

Demo2.java4

AspectJ的注解方式(最简单的方式)

AccountServiceImpl.java4

applicationContext3.xml4

Demo3.java4

Spring框架的AOP技术（注解方式）

CustomerDao.java

package com.itheima.demo1;

public interface CustomerDao {
  public void save();
  public void update();
}

CustomerDaoImpl.java

package com.itheima.demo1;

public class CustomerDaoImpl implements CustomerDao {

  @Override
  public void save() {
    System.out.println("保存客户...");
  }

  @Override
  public void update() {
    System.out.println("修改客户...");
  }

}

MyAspectAnno.java

package com.itheima.demo1;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

/**
 * 注解方式的切面类
 */
@Aspect //声明本类为切面类 相当于这一行:<aop:aspect ref="myAspectAnno">
public class MyAspectAnno {
  
  /**
   * 通知类型: @Before表示前置通知
   * 格式: @通知类型(value="切入点方法")
   */
  //@Before(value="execution(public * com.itheima.demo1.CustomerDaoImpl.save())")
  @Before(value="MyAspectAnno.fn()") //直接引入自己定义切入点即可   类名.方法
  public void log() {
    System.out.println("注解方式的切面类写日志...");
  }
  
  /**
   * 最终通知:方法执行成功或者异常都会执行
   */
  //@After(value="execution(public * com.itheima.demo1.CustomerDaoImpl.save())")
  @After(value="MyAspectAnno.fn()")
  public void after() {
    System.out.println("注解方式的切面最终通知类型...");
  }
  
  /**
   * 环绕通知
   */
  @Around(value="MyAspectAnno.fn()")
  public void around(ProceedingJoinPoint joinPoint){
    System.out.println("环绕通知1...");
    try {
      //让目标对象的方法执行
      joinPoint.proceed();
    } catch (Throwable e) {
      e.printStackTrace();
    }
    System.out.println("环绕通知2...");
  }
  
  /** 
   * 自定义切入点  然后再引入 方便，相同的不用每次都复制粘贴了
   * @Pointcut 
   */
  @Pointcut(value="execution(public * com.itheima.demo1.CustomerDaoImpl.save())")
  public void fn(){}//随便写个方法 但是必须有个方法 因为注解不能单独存在 
  
  
  
}

applicationContext.xml

<?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:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx.xsd">
  <!-- 约束很全的一个xml 以后直接复制就行了 -->
  
  
  <!-- 开启自动代理  注意注解方式的AOP必须开启自动代理-->
  <aop:aspectj-autoproxy/>
  
  
  <!-- 配置目标对象 -->          <!-- 可以自动提示，不用复制了 -->
  <bean id="customerDao" class="com.itheima.demo1.CustomerDaoImpl"/>
  
  <!-- 配置切面类 -->
  <bean id="myAspectAnno" class="com.itheima.demo1.MyAspectAnno"></bean>
  
  <!-- 切面类的配置改用注解来实现了 -->
  <!-- <aop:config>
    <aop:aspect ref="myAspectAnno">
      <aop:after method="log" pointcut=""/>
    </aop:aspect>
  </aop:config> -->
  
</beans>

Demo1.java

package com.itheima.demo1;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
  
  @Resource(name="customerDao")
  private CustomerDao customerDao;//注解配置的其实是实现类就行了
  
  @Test
  public void run1(){
    customerDao.save();
    customerDao.update();
    //注解方式 别忘了xml里开启自动代理
  }

}

Spring框架的JDBC模板技术

applicationContext.xml2

重要配置，主要学习在此

<?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:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx.xsd">
  
  <!-- 配置spring内置连接池   默认单例正好连接池就要一个 
  <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql:///spring_day03"/>
    <property name="username" value="root"/>
    <property name="password" value="1111"/>
  </bean> -->
  
  <!-- 配置dbcp的连接池 
  <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql:///spring_day03"/>
    <property name="username" value="root"/>
    <property name="password" value="1111"/>
  </bean>-->
  
  <!-- 配置c3p0连接池  ★ 以后用的都是这个连接池-->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
    <property name="user" value="root"/>
    <property name="password" value="1111"/>
  </bean>
  
  <!-- 配置jdbc的模板类 -->
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
</beans>

Demo1.java

原始new方法

package com.itheima.demo1;

import org.junit.Test;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.datasource.DriverManagerDataSource;

/**
 * 演示jdbc的模板类
 */
public class Demo1 {
  /**
   * 演示模板类1:原始new方法
   */
  @Test
  public void run1() {
    //spring框架提供了内置的连接池，不想使用的话可以自己整合其他的连接池
    DriverManagerDataSource dataSource=new DriverManagerDataSource();//spring内置连接池
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql:///spring_day03");
    dataSource.setUsername("root");
    dataSource.setPassword("1111");
    
    //创建模板类 (需要连接池)
    JdbcTemplate template =new JdbcTemplate();
    //设置连接池
    template.setDataSource(dataSource);
    //完成操作  类似dbUtils
    template.update("insert into t_account values(null,?,?)","天河",50000);
    //不加事务有内置事务。。
  }
  
}

Demo1_1.java

IOC的方式使用连接池和springJdbc模板操作数据库

package com.itheima.demo1;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import javax.annotation.Resource;

import org.apache.commons.dbcp.BasicDataSource;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**
 * 演示jdbc的模板类:IOC方式
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1_1 {
  
  @Resource(name="jdbcTemplate")
  private JdbcTemplate template;
  
  /**
   * 演示模板类2:IOC方式
   * 上面连接池和模板类自己new了，不符合springIOC的规范 于是配置连接池 让spring的IOC容器帮我们new
   * 
   * 需要先注入了:private JdbcTemplate template;属性
   */
  @Test
  public void run1() {
    template.update("insert into t_account values(null,?,?)", "菱纱",80000);
  }
  
  /**
   * dbcp连接池简单回忆   测代码还是run1 不用改
   */
  public void run2() {
    /*BasicDataSource dataSource =new BasicDataSource();
    dataSource.setDriverClassName(driverClassName);
    dataSource.setUrl(url);
    dataSource.setUsername(username);
    dataSource.setPassword(password);*/
  }
  
  /**
   * c3p0也一样  导个包 然后连接池的配置稍微改下即可  其他的代码都一样，不用动
   */
  
  
  /*下面演示jdbc模板的一些基本方法*/
  /**
   * update(String sql,Object ...params)   可以完成增删改 类似dbUtils
   */
  @Test
  public void run3() {
    template.update("update t_account set name=? where name=?","韩菱纱","菱纱");
  }
  
  /**
   * 删除测试
   */
  @Test
  public void run4() {
    template.update("delete from t_account where id=?",6);
  }
  
  /**
   * 测试查询:通过主键来查询一条记录
   */
  @Test
  public void run5() {
    Account account = template.queryForObject("select * from t_account where id=?", new BeanMapper(), 1);
    System.out.println(account);
  }
  
  /**
   * 查询所有的数据
   */
  @Test
  public void run6() {
    List<Account> list = template.query("select * from t_account", new BeanMapper());
    for (Account account : list) {
      System.out.println(account);
    }
  }
  
}

/**
 * 自己主动实现对应接口 封装数据,一行一行封装(不用写循环)
 * @author Administrator
 *
 */
class BeanMapper implements RowMapper<Account>{

  @Override
  public Account mapRow(ResultSet rs, int rowNum) throws SQLException {
    Account ac=new Account();
    ac.setId(rs.getInt("id"));
    ac.setName(rs.getString("name"));
    ac.setMoney(rs.getDouble("money"));
    return ac;
  }
  
}

Spring框架的事务管理

搭建事务管理转账案例的环境和自己编码处理事务

AccountDao.java

package com.itheima.demo1;

public interface AccountDao {
  
  public void outMoney(String out,double money);
  
  public void inMoney(String in,double money);
}

AccountDaoImpl.java

package com.itheima.demo1;

import org.springframework.jdbc.core.support.JdbcDaoSupport;

/**
 * @author Administrator
 *
 */
public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

  /*//纯配置文件方式 注入jdbc模板类
  private JdbcTemplate jdbcTemplate;
  public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
    this.jdbcTemplate = jdbcTemplate;
  }*/  //很明显会发现每个dao都要注入一次  即每个daoimpl都要有一个属性jdbcTemplate 
     //那么不如放到一个父类中去，spring给我们提供了父类  (注意下工厂默认单例)   在上面加上继承代码

  /**
   * 扣钱
   */
  public void outMoney(String out, double money) {
    getJdbcTemplate().update("update t_account set money=money-? where name=?",money,out);
  }

  /**
   * 加钱
   */
  public void inMoney(String in, double money) {
    getJdbcTemplate().update("update t_account set money=money+? where name=?",money,in);
  }

}

AccountService.java

package com.itheima.demo1;

public interface AccountService {
  
  public void pay(String out,String in,double money);

}

AccountServiceImpl.java

package com.itheima.demo1;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {

  private AccountDao accountDao;//以后有接口就写接口 大公司开发都是先设计好接口的
  public void setAccountDao(AccountDao accountDao) {
    this.accountDao = accountDao;
  }//配置文件法   非注解法    写个配置文件，给个set方法   property配个属性值就行了

  private TransactionTemplate transactionTemplate;
  public void setTransactionTemplate(TransactionTemplate transactionTemplate) {
    this.transactionTemplate = transactionTemplate;
  }//别忘了在AccountServiceImpl的bean里面注入此属性



  /**
   * 转账方法   普通环境  不加事务
   */
  /*public void pay(String out, String in, double money) {
    //先扣钱
    accountDao.outMoney(out, money);
    //模拟异常
    int a=10/0;
    //再加钱
    accountDao.inMoney(in, money);
  }*/
  
  /**
   * 转账方法，加上事务处理
   */
  public void pay(final String out, final String in, final double money) {
    transactionTemplate.execute(new TransactionCallbackWithoutResult() {
      
      //事务的执行，如果没有问题，提交。如果出现了异常，回滚
      protected void doInTransactionWithoutResult(TransactionStatus status) {
        //先扣钱
        accountDao.outMoney(out, money);
        //模拟异常
        //int a=10/0;
        //再加钱
        accountDao.inMoney(in, money);
      }
    });
  }

}

applicationContext.xml3

<?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:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx.xsd">
  
  <!-- 配置c3p0连接池  ★ 以后用的都是这个连接池-->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
    <property name="user" value="root"/>
    <property name="password" value="1111"/>
  </bean>
  
  <!-- 配置平台事务管理器  底层都是平台事务管理器做-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <!-- 注入c3p0连接池 -->
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  <!-- 手动编码(了解) 提供了模板类 使用该类处理事务比较简单 要用此类就配置下（中间还要配一个模板，配置看上去麻烦死了，只是为了写代码简单） -->
  <bean id="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">
    <!-- 注入平台事务管理器 -->
    <property name="transactionManager" ref="transactionManager"/>
  </bean>
  
  <!-- 配置jdbc的模板类 
  <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  让JdbcDaoSupport类注入连接池时帮你创建模板，不用注入了
  -->  
  
  <!-- 配置业务层和持久层 -->
  <bean id="accountService" class="com.itheima.demo1.AccountServiceImpl">
    <!-- service注入DAO -->
    <property name="accountDao" ref="accountDao"/>
    <property name="transactionTemplate" ref="transactionTemplate"/>
  </bean>
  <!-- <bean id="accountDao" class="com.itheima.demo1.AccountDaoImpl">
    DAO注入jdbc模板类   继承了父类 属性在父类里
    <property name="jdbcTemplate" ref="jdbcTemplate"/>
  </bean> -->
  <!-- 然而对于父类来说，直接注入连接池也行了  此时没有注入模板 模板为null,
    父类会在注入连接池时帮你创建一个模板  这样直接配置连接池就行了 省掉了上面模板的配置 可以注释了-->
  <bean id="accountDao" class="com.itheima.demo1.AccountDaoImpl">
    <!-- DAO直接注入连接池   继承了父类 属性在父类里-->
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
</beans>

Demo1.java3

package com.itheima.demo1;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class Demo1 {
  
  @Resource(name="accountService")  //直接用jdk的注解  没有开启自动代理 可以吗?  事实证明可以
  private AccountService accountService;


  @Test
  public void run1() {
    accountService.pay("天河", "紫英", 10000);
  }

}

Spring框架的声明式事务管理，通过配置文件来完成事务管理(AOP思想)

AspectJ的XML方式

AccountDao.java AccountDaoImpl.java AccountService.java同上

AccountServiceImpl.java4

package com.itheima.demo2;

import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.TransactionCallbackWithoutResult;
import org.springframework.transaction.support.TransactionTemplate;

public class AccountServiceImpl implements AccountService {

  private AccountDao accountDao;//以后有接口就写接口 大公司开发都是先设计好接口的
  public void setAccountDao(AccountDao accountDao) {
    this.accountDao = accountDao;
  }//配置文件法   非注解法    写个配置文件，给个set方法   property配个属性值就行了

  /**
   * 转账方法 spring声明式事务(不手写)
   * 并且AOP思想 不改源代码  用切面类 而事务管理代码是死的，spring框架已经帮我们写好了  现在需要管理事务，只需要配置xml即可
   */
  public void pay(String out, String in, double money) {
    //先扣钱
    accountDao.outMoney(out, money);
    //模拟异常
    int a=10/0;
    //再加钱
    accountDao.inMoney(in, money);
  }
  
}

applicationContext2.xml4

<?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:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx.xsd">
  
  <!-- 配置c3p0连接池  ★ 以后用的都是这个连接池-->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
    <property name="user" value="root"/>
    <property name="password" value="1111"/>
  </bean>
  
  <!-- 配置平台事务管理器  底层都是平台事务管理器做  任何spring事务处理方式都要有他-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  <!-- 声明式事务 采用xml配置文件的方式(AOP) -->
  <!-- 1.先配置通知  [就是具体的增强逻辑方法的类(此处是spring提供了 在引入的命名空间tx下)]-->
  <tx:advice id="myAdvice" transaction-manager="transactionManager">
    <tx:attributes>
      <!-- 此处有pay，下面也有pay 此处主要是配通知方法的  以及事务的各种属性 -->
      <!-- 此处可以给方法设置各种数据库属性(隔离级别，传播行为) 
          name    ：绑定事务的方法名，可以使用通配符，可以配置多个。
          propagation ：传播行为
          isolation ：隔离级别
          read-only ：是否只读
          timeout   ：超时信息
          rollback-for：发生哪些异常回滚.
          no-rollback-for：发生哪些异常不回滚.
      -->
      <tx:method name="pay*" propagation="REQUIRED"/> <!--propagation="REQUIRED"保证调用过程中是同一个事务，不配默认也是这个  -->
      <!-- <tx:method name="find" read-only="true"/>  service里有多个方法时 配多行即可  查询方法可以设置只读缓存属性-->
    </tx:attributes>
  </tx:advice>
  
  <!-- 2.再配置AOP()
    如果是自己编写的AOP,使用<aop:aspect>配置
    如果使用的是spring框架提供的通知,使用aop:advisor配置
   -->
   <aop:config>
    <aop:advisor advice-ref="myAdvice" pointcut="execution(public * com.itheima.demo2.AccountServiceImpl.pay(..))"/> <!-- 引用通知 -->
   </aop:config>
  
  
  
  <!-- 配置业务层和持久层 -->
  <bean id="accountService" class="com.itheima.demo2.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"/>
  </bean>
  <bean id="accountDao" class="com.itheima.demo2.AccountDaoImpl">
    <!-- DAO直接注入连接池   继承了父类 属性在父类里-->
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  
</beans>

Demo2.java4

package com.itheima.demo2;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext2.xml")
public class Demo2 {
  
  @Resource(name="accountService")  //直接用jdk的注解  没有开启自动代理 可以吗?  事实证明可以
  private AccountService accountService;

  @Test
  public void run1() {
    accountService.pay("天河", "紫英", 10000);
  }

}

AspectJ的注解方式(最简单的方式)

AccountDao.java AccountDaoImpl.java AccountService.java同上

AccountServiceImpl.java4

package com.itheima.demo3;

import org.springframework.transaction.annotation.Transactional;

/**
 * 在类上加@Transactional注解 ，则类中所有的方法全部有了事务
 * 也可以在单个方法上加@Transactional 这样就是被加的方法有了事务
 * @author Administrator
 *
 */
@Transactional   //加个括号可以设置各种属性  但是设置属性时最好将注解写到单个方法上，不然所有的方法都生效了
public class AccountServiceImpl implements AccountService {

  private AccountDao accountDao;//以后有接口就写接口 大公司开发都是先设计好接口的
  public void setAccountDao(AccountDao accountDao) {
    this.accountDao = accountDao;
  }//配置文件法   非注解法    写个配置文件，给个set方法   property配个属性值就行了

  /**
   * 转账方法 spring声明式事务(不手写)
   * 并且AOP思想 不改源代码  用切面类 而事务管理代码是死的，spring框架已经帮我们写好了  现在需要管理事务，只需要配置xml即可
   * 
   * 注解方式:超级简单   配置一个事务管理器transactionManager  然后开启事务注解  然后在类或者方法上加@Transactional注解即可
   */
  public void pay(String out, String in, double money) {
    //先扣钱
    accountDao.outMoney(out, money);
    //模拟异常
    int a=10/0;
    //再加钱
    accountDao.inMoney(in, money);
  }
  
}

applicationContext3.xml4

<?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:context="http://www.springframework.org/schema/context"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans 
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd
  http://www.springframework.org/schema/tx 
  http://www.springframework.org/schema/tx/spring-tx.xsd">
  
  <!-- 配置c3p0连接池  ★ 以后用的都是这个连接池-->
  <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <property name="driverClass" value="com.mysql.jdbc.Driver"/>
    <property name="jdbcUrl" value="jdbc:mysql:///spring_day03"/>
    <property name="user" value="root"/>
    <property name="password" value="1111"/>
  </bean>
  
  <!-- 配置平台事务管理器  底层都是平台事务管理器做  任何spring事务处理方式都要有他-->
  <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  <!-- 注解方式处理事务 -->
  <!-- 先开启事务的注解 -->
  <tx:annotation-driven transaction-manager="transactionManager"/>
  
  <!-- 配置业务层和持久层 -->
  <bean id="accountService" class="com.itheima.demo3.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"/>
  </bean>
  <bean id="accountDao" class="com.itheima.demo3.AccountDaoImpl">
    <!-- DAO直接注入连接池   继承了父类 属性在父类里-->
    <property name="dataSource" ref="dataSource"/>
  </bean>
  
  
</beans>

Demo3.java4

package com.itheima.demo3;

import javax.annotation.Resource;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext3.xml")
public class Demo3 {
  
  @Resource(name="accountService")  //直接用jdk的注解  没有开启自动代理 可以吗?  事实证明可以
  private AccountService accountService;

  @Test
  public void run1() {
    accountService.pay("天河", "紫英", 10000);
  }

}