快速学习-AOP 的相关概念

第1章 AOP 的相关概念[理解]

1.1 AOP 概述

1.1.1 什么是 AOP

1.1.2 AOP 的作用及优势

作用：
在程序运行期间，不修改源码对已有方法进行增强。
优势：
减少重复代码
提高开发效率
维护方便

1.1.3 AOP 的实现方式

使用动态代理技术

1.2 AOP 的具体应用

1.2.1 案例中问题

这是我们昨天课程中做的增删改查例子。下面是客户的业务层实现类。我们能看出什么问题吗?

@Service("accountService")
public class AccountServiceImpl implements IAccountService{

    @Override
    public void saveAccount() {
        System.out.println("执行了保存");
        int i=1/0;
    }

    @Override
    public void updateAccount(int i) {
        System.out.println("执行了更新"+i);

    }

    @Override
    public int deleteAccount() {
        System.out.println("执行了删除");
        return 0;
    }
}

问题就是：
事务被自动控制了。换言之，我们使用了 connection 对象的 setAutoCommit(true)此方式控制事务，如果我们每次都执行一条 sql 语句，没有问题，但是如果业务方法一次要执行多条 sql语句，这种方式就无法实现功能了。

请看下面的示例：
我们在业务层中多加入一个方法。

业务层接口

/**
* 转账
* @param sourceName
* @param targetName
* @param money
*/
void transfer(String sourceName,String targetName,Float money);

业务层实现类

@Override
public void transfer(String sourceName, String targetName, Float money) {
	//根据名称查询两个账户信息
	Account source = accountDao.findByName(sourceName);
	Account target = accountDao.findByName(targetName);
	//转出账户减钱，转入账户加钱
	source.setMoney(source.getMoney() - money);
	target.setMoney(target.getMoney() + money);
	//更新两个账户
	accountDao.update(source);
	int i = 1 / 0; //模拟转账异常
	accountDao.update(target);
}

当我们执行时，由于执行有异常，转账失败。但是因为我们是每次执行持久层方法都是独立事务，导致无法实现事务控制（不符合事务的一致性）

1.2.2 问题的解决

解决办法：
让业务层来控制事务的提交和回滚。（这个我们之前已经在 web 阶段讲过了）

改造后的业务层实现类：
注：此处没有使用 spring 的 IoC.

public class AccountServiceImpl implements IAccountService{

    private IAccountDao accountDao;

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

    @Override
    public List<Account> findAllAccount() {
       return accountDao.findAllAccount();
    }

    @Override
    public Account findAccountById(Integer accountId) {
        return accountDao.findAccountById(accountId);

    }

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }

    @Override
    public void updateAccount(Account account) {
        accountDao.updateAccount(account);
    }

    @Override
    public void deleteAccount(Integer acccountId) {
        accountDao.deleteAccount(acccountId);
    }

    @Override
    public void transfer(String sourceName, String targetName, Float money) {
        System.out.println("transfer....");
            //2.1根据名称查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //2.2根据名称查询转入账户
            Account target = accountDao.findAccountByName(targetName);
            //2.3转出账户减钱
            source.setMoney(source.getMoney()-money);
            //2.4转入账户加钱
            target.setMoney(target.getMoney()+money);
            //2.5更新转出账户
            accountDao.updateAccount(source);

//            int i=1/0;

            //2.6更新转入账户
            accountDao.updateAccount(target);
    }
}

1.2.3 新的问题

上一小节的代码，通过对业务层改造，已经可以实现事务控制了，但是由于我们添加了事务控制，也产生了一个新的问题：

业务层方法变得臃肿了，里面充斥着很多重复代码。并且业务层方法和事务控制方法耦合了。试想一下，如果我们此时提交，回滚，释放资源中任何一个方法名变更，都需要修改业务层的代码，况且这还只是一个业务层实现类，而实际的项目中这种业务层实现类可能有十几个甚至几十个。

思考：
这个问题能不能解决呢？答案是肯定的，使用下一小节中提到的技术。

1.2.4 动态代理回顾

1.2.4.1 动态代理的特点

字节码随用随创建，随用随加载。
它与静态代理的区别也在于此。因为静态代理是字节码一上来就创建好，并完成加载。
装饰者模式就是静态代理的一种体现。

1.2.4.2 动态代理常用的有两种方式

基于接口的动态代理
提供者：JDK 官方的 Proxy 类。
要求：被代理类最少实现一个接口。
基于子类的动态代理
提供者：第三方的 CGLib，如果报 asmxxxx 异常，需要导入 asm.jar。
要求：被代理类不能用 final 修饰的类（最终类）。

1.2.4.3 使用 JDK 官方的 Proxy 类创建代理对象

此处我们使用的是一个演员的例子：
在很久以前，演员和剧组都是直接见面联系的。没有中间人环节。
而随着时间的推移，产生了一个新兴职业：经纪人（中间人），这个时候剧组再想找演员就需要通过经纪人来找了。下面我们就用代码演示出来。

public interface IActor {
	/**
	 * 基本演出
	 * @param money
	 */
	public void basicAct(float money);
	/**
	 * 危险演出
	 * @param money
	 */
	public void dangerAct(float money);
}

/**
 * 一个演员
 */
//实现了接口，就表示具有接口中的方法实现。即：符合经纪公司的要求
public class Actor implements IActor {
	public void basicAct(float money) {
		System.out.println("拿到钱，开始基本的表演：" + money);
	}
	public void dangerAct(float money) {
		System.out.println("拿到钱，开始危险的表演：" + money);
	}
}

public class Client {
	public static void main(String[] args) {
		//一个剧组找演员：
		final Actor actor = new Actor(); //直接
		/**
		 * 代理：
		 * 间接。
		 * 获取代理对象：
		 * 要求：
		 * 被代理类最少实现一个接口
		 * 创建的方式
		 * Proxy.newProxyInstance(三个参数)
		 * 参数含义：
		 * ClassLoader：和被代理对象使用相同的类加载器。
		 * Interfaces：和被代理对象具有相同的行为。实现相同的接口。
		 * InvocationHandler：如何代理。
		 * 策略模式：使用场景是：
		 * 数据有了，目的明确。
		 * 如何达成目标，就是策略。
		 * 
		 */
		IActor proxyActor = (IActor) Proxy.newProxyInstance(
			actor.getClass().getClassLoader(),
			actor.getClass().getInterfaces(),
			new InvocationHandler() {
				/**
				 * 执行被代理对象的任何方法，都会经过该方法。
				 * 此方法有拦截的功能。
				 * 
				 * 参数：
				 * proxy：代理对象的引用。不一定每次都用得到
				 * method：当前执行的方法对象
				 * args：执行方法所需的参数
				 * 返回值：
				 * 当前执行方法的返回值
				 */
				@Override
				public Object invoke(Object proxy, Method method, Object[] args)
				throws Throwable {
					String name = method.getName();
					Float money = (Float) args[0];
					Object rtValue = null; //每个经纪公司对不同演出收费不一样，此处开始判断
					if ("basicAct".equals(name)) {
						//基本演出，没有 2000 不演
						if (money > 2000) {
							//看上去剧组是给了 8000，实际到演员手里只有 4000
							//这就是我们没有修改原来 basicAct 方法源码，对方法进行了增强
							rtValue = method.invoke(actor, money / 2);
						}
					}
					if ("dangerAct".equals(name)) {
						//危险演出,没有 5000 不演
						if (money > 5000) {
							//看上去剧组是给了 50000，实际到演员手里只有 25000
							//这就是我们没有修改原来 dangerAct 方法源码，对方法进行了增强
							rtValue = method.invoke(actor, money / 2);
						}
					}
					return rtValue;
				}
			});
		//没有经纪公司的时候，直接找演员。
		// actor.basicAct(1000f);
		// actor.dangerAct(5000f);
		//剧组无法直接联系演员，而是由经纪公司找的演员
		proxyActor.basicAct(8000 f);
		proxyActor.dangerAct(50000 f);
	}
}

1.2.4.4 使用 CGLib 的 Enhancer 类创建代理对象

public class Actor { //没有实现任何接口
	public void basicAct(float money) {
		System.out.println("拿到钱，开始基本的表演：" + money);
	}
	public void dangerAct(float money) {
		System.out.println("拿到钱，开始危险的表演：" + money);
	}
}
public class Client {
	/**
	 * 基于子类的动态代理
	 * 要求：
	 * 被代理对象不能是最终类
	 * 用到的类：
	 * Enhancer
	 * 用到的方法：
	 * create(Class, Callback)
	 * 方法的参数：
	 * Class：被代理对象的字节码
	 * Callback：如何代理
	 * @param args
	 */
	public static void main(String[] args) {
		final Actor actor = new Actor();
		Actor cglibActor = (Actor) Enhancer.create(actor.getClass(),
			new MethodInterceptor() {
				/**
				* 执行被代理对象的任何方法，都会经过该方法。在此方法内部就可以对被代理对象的任何
				方法进行增强。
				* 
				* 参数：
				* 前三个和基于接口的动态代理是一样的。
				* MethodProxy：当前执行方法的代理对象。
				* 返回值：
				* 当前执行方法的返回值
				*/
				@Override
				public Object intercept(Object proxy, Method method, Object[] args,
					MethodProxy methodProxy) throws Throwable {
					String name = method.getName();
					Float money = (Float) args[0];
					Object rtValue = null;
					if ("basicAct".equals(name)) {
						//基本演出
						if (money > 2000) {
							rtValue = method.invoke(actor, money / 2);
						}
					}
					if ("dangerAct".equals(name)) {
						//危险演出
						if (money > 5000) {
							rtValue = method.invoke(actor, money / 2);
						}
					}
					return rtValue;
				}
			});
		cglibActor.basicAct(10000);
		cglibActor.dangerAct(100000);
	}
}

思考：
这个故事（示例）讲完之后，我们从中受到什么启发呢？它到底能应用在哪呢？

1.2.5 解决案例中的问题

public class BeanFactory {
	/**
	 * 创建账户业务层实现类的代理对象
	 * @return
	 */
	public static IAccountService getAccountService() {
		//1.定义被代理对象
		final IAccountService accountService = new AccountServiceImpl();
		//2.创建代理对象
		IAccountService proxyAccountService = (IAccountService)
		Proxy.newProxyInstance(accountService.getClass().getClassLoader(),
			accountService.getClass().getInterfaces(), new InvocationHandler() {
				/**
				 * 执行被代理对象的任何方法，都会经过该方法。
				 * 此处添加事务控制
				 */
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					Object rtValue = null;
					try {
						//开启事务
						TransactionManager.beginTransaction();
						//执行业务层方法
						rtValue = method.invoke(accountService, args);
						//提交事务
						TransactionManager.commit();
					} catch (Exception e) {
						//回滚事务
						TransactionManager.rollback();
						e.printStackTrace();
					} finally {
						//释放资源
						TransactionManager.release();
					}
					return rtValue;
				}
			});
		return proxyAccountService;
	}
}

当我们改造完成之后，业务层用于控制事务的重复代码就都可以删掉了。