Spring: AOP

public void transfer(String sourceName, String targetName, Float money) {
        Account source = accountDao.findAccountByName(sourceName);
        Account target=accountDao.findAccountByName(targetName);
        source.setMoney(source.getMoney()-money);
        target.setMoney(target.getMoney()+money);
        accountDao.updateAccount(source);
        accountDao.updateAccount(target);
}

public class AccountDaoImpl_OLD implements IAccountDao {
    private QueryRunner runner;
    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }
    public List<Account> findAllAccount() {
        try {
            return runner.query("select * from account",new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            throw  new RuntimeException(e);
        }
    }
    //...
}

public class AccountServiceImpl implements IAccountService {
    private IAccountDao accountDao;
    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }
}

public class AccountDaoImpl implements IAccountDao {
    private QueryRunner runner;
    private ConnectionUtils connectionUtils;
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void setRunner(QueryRunner runner) {
        this.runner = runner;
    }

    public List<Account> findAllAccount() {
        try {
            return runner.query(connectionUtils.getThreadConnection(),"select * from account",new BeanListHandler<Account>(Account.class));
        } catch (SQLException e) {
            throw  new RuntimeException(e);
        }
    }
}

public class ConnectionUtils {
    private ThreadLocal<Connection> tl =new ThreadLocal<Connection>();
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    //获取当前线程上的连接
    public Connection getThreadConnection(){
        //1.先从ThreadLocal上获取
        Connection conn=tl.get();
        try {
            //2.判断当前线程上是否有连接
            if (conn == null) {
                //3.从数据源中获取一个连接，并且存入ThreadLocal
                conn = dataSource.getConnection();
                tl.set(conn);
            }
            //4.返回当前线程上的连接
            return conn;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
    //把连接和线程解绑
    public void removeConnection(){
        tl.remove();
    }
}

public class TransactionManager {
    private ConnectionUtils connectionUtils;

    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }

    public void beginTransaction(){
        try{
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public void commit(){
        try{
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public void rollback(){
        try{
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    public void release(){
        try{
            connectionUtils.getThreadConnection().close();//还回连接池
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

public class AccountServiceImpl_OLD implements IAccountService {
    private IAccountDao accountDao;
    private TransactionManager transactionManager;

    public void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public void setAccountDao(IAccountDao accountDao) {
        this.accountDao = accountDao;
    }

    public List<Account> findAllAccount() {
        try{
            //1.开启事务
            transactionManager.beginTransaction();
            //2.执行操作
            List<Account> accounts =  accountDao.findAllAccount();
            //3.提交事务
            transactionManager.commit();
            //4.返回结果
            return accounts;
        }catch (Exception e){
            //5.回滚操作
            transactionManager.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放连接
            transactionManager.release();
        }
    }
}

final Producer producer=null;//final且要求Producer实现接口
IProducer proxyProducer= (IProducer) Proxy.newProxyInstance(producer.getClass().getClassLoader(), producer.getClass().getInterfaces(), new InvocationHandler() {
    		//执行被代理对象的任何接口方法都会经过该方法
    		//proxy：代理对象的引用，Method当前执行的方法，args当前执行方法所需要的函数
    		//和被代理对象方法有相同的返回值
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //提供增强的代码
                Object retuernValue=null;
                //1.获取方法执行的参数
                Float money = (Float) args[0];
                //2.判断当前的方法是不是销售
                if ("saleProduct".equals(method.getName())){
                    retuernValue= method.invoke(producer,money*0.8f);
                }
                return retuernValue;
            }
        });
proxyProducer.saveProduct(1000f);
//输出：拿到钱销售产品拿到钱800.0
//消费者拿出1000，经销商拿走200，厂家得到800

public class BeanFactory {
    private IAccountService accountService;
    private TransactionManager transactionManager;

    public final void setTransactionManager(TransactionManager transactionManager) {
        this.transactionManager = transactionManager;
    }

    public void setAccountService(IAccountService accountService) {
        this.accountService = accountService;
    }

    public IAccountService getAccountService() {
        return (IAccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), new InvocationHandler() {
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //添加事务的支持
                Object rtValue=null;
                try{
                    //1.开启事务
                    transactionManager.beginTransaction();
                    //2.执行操作
                    rtValue=method.invoke(accountService, args);
                    //3.提交事务
                    transactionManager.commit();
                    //4.返回结果
                    return rtValue  ;
                }catch (Exception e){
                    //5.回滚操作
                    transactionManager.rollback();
                    throw new RuntimeException(e);
                }finally {
                    //6.释放连接
                    transactionManager.release();
                }
            }
        });
    }
}

//测试代码
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:bean.xml")
public class AccountService {
    @Autowired
    @Qualifier("proxyAccountService")
    private IAccountService as;
    @Test
    public void transfer(){
        as.transfer("bbb","ccc",234f);
    }
}

//测试函数
ApplicationContext ac= new ClassPathXmlApplicationContext("bean.xml");
IAccountService as= (IAccountService) ac.getBean("accountService");
as.saveAccount();

//Logger中增加环绕通知
public void aroundPrinting(ProceedingJoinPoint pjp){
    System.out.println("aroundPrinting");
}

as.saveAccount();
//输出：aroundPrinting
//没有执行保存输出

//修改环绕通知
public Object aroundPrinting(ProceedingJoinPoint pjp){
	Object rtValue=null;
    try{
        Object[] args=pjp.getArgs();
        System.out.println("aroundPrinting--前置通知");
        rtValue=pjp.proceed(args);
        System.out.println("aroundPrinting--后置通知");
        return rtValue;
    }catch (Throwable t){
        System.out.println("aroundPrinting--异常通知");
        throw new RuntimeException(t);
    }finally {
        System.out.println("aroundPrinting--最终通知");
    }
}

//测试
as.saveAccount();
/**
aroundPrinting--前置通知
执行了保存
aroundPrinting--后置通知
aroundPrinting--后置通知
*/

@Around("pt1()")
    public Object aroundAdvice(ProceedingJoinPoint pjp){
        Object rtValue=null;
        try{
            //1.获取参数
            Object[] args = pjp.getArgs();
            //2.开启事务
            this.beginTransaction();
            //3.执行方法
            rtValue=pjp.proceed(args);
            //4.提交事务
            this.commit();
            return rtValue;
        }catch (Throwable e){
            //5.回滚事务
            this.rollback();
            throw new RuntimeException(e);
        }finally {
            //6.释放资源
            this.release();
        }
    }