AOP的相关概念

SpringMVC学习记录文章目录：
1、程序的耦合和解耦思路
2、使用springIOC解决程序耦合的前期准备
3、BeanFactory和ApplicationContext的区别及ApplicationContext接口的实现类
4、bean标签及其实例化的3种方式
5、bean的作用范围和生命周期
6、Spring的依赖注入
7、基于注解的IOC环境搭建
8、基于注解的IOC-常用注解（Spring2.5规范）
9、Spring常用注解-新（Spring2.5规范以上）
10、Spring整合Junit单元测试
11、AOP的相关概念
12、Spring中AOP的术语
13、SpringAOP常用标签解释说明
14、SpringAOP中切入点表达式说明
15、SpringAOP类型说明及环绕通知的特殊说明
16、基于xml的SpringAOP配置
17、SpringAOP常用注解
18、基于注解的SpringAOP配置
19、Spring中的JdbcTemplate
20、Spring中的事务控制

1.AOP的概述？

1.1 什么是AOP？

看看百度百科是如何解释的：
在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
简单的说它就是把程序重复的代码抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上，对已有方法进行增强。

1.2 AOP有什么作用和优势呢？

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

1.3 AOP用什么实现？

动态代理技术

2.动态代理概述

2.1 动态代理的特点

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

2.2 动态代理常用的两种方式

2.2.1 基于接口的动态代理

• 提供者：JDK官方的Proxy类。
• 要求：被代理类最少实现一个接口。
• 创建对象的方法：newProxyInstance(ClassLoader, Class[], InvocationHandler)
  • 参数含义：
    • ClassLoader：类加载器，和被代理使用系统的类加载器。(一般都是通用写法 类.getClass().getClassLoader())
    • Class[]：字节码数组，被代理类实现的接口。(要求代理对象和被代理对象有相同的行为，一般都是通用写法 类.getClass().getInterfaces())
    • InvocationHandler： 它是一个接口，就是用于提供增强代码的接口。一般都是写一个接口的实现类，实现类可以是匿名内部类。它的含义就是如何代理，此处的代码只能是谁用谁提供。
      • 策略模式
        • 使用要求：已有数据、目的明确，达成目标的过程就是策略。
        • DBUtils中的ResultSetHandler就是策略模式的应用。

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

代码示例：

/**
 * 一个经纪公司的要求:
 * 		能做基本的表演和危险的表演
*/
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();//直接
		
		
		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(8000f);
		proxyActor.dangerAct(50000f);
	}
}

2.2.2 基于子类的动态代理

• 提供者：第三方的CGLib，如果报asmxxxx异常，需要导入asm.jar。
• 要求：被代理类不能用final修饰的类（最终类）。
• 用到的类：Enhancer
• 用到的方法：create(Class, Callback)
  • 方法的参数:
    • Class：被代理对象的字节码
    • Callback：如何代理，它和InvocationHandle的作用是一样的。它是一个接口，一般使用该接口的子接口MethodInterceptor，在创建时也是创建该接口的匿名内部类。

代码示例：
还是上面演员的例子，不实现接口。

/**
 * 一个演员
*/
public class Actor{//没有实现任何接口
	
	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();
		
		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);
	}
}

3.使用动态代理实现客户业务层的事物控制

思路只有一个：使用动态代理技术创建客户业务层的代理对象，在执行CustomerServiceImpl时，对里面的方法进行增强，加入事务的支持。

/**
 * 用于创建客户业务层对象工厂（当然也可以创建其他业务层对象，只不过此处不做那么繁琐）
*/
public class BeanFactory {
	
	/**
	 * 获取客户业务层对象的代理对象
	 * @return
	 */
	public static ICustomerService getCustomerService() {
		//定义客户业务层对象
		final ICustomerService customerService = new CustomerServiceImpl();
		//生成它的代理对象
		ICustomerService proxyCustomerService = (ICustomerService) 
			Proxy.newProxyInstance(customerService.getClass().getClassLoader()
			,customerService.getClass().getInterfaces(), 
			new InvocationHandler() {
			//执行客户业务层任何方法，都会在此处被拦截，我们对那些方法增强，加入事务。	
			@Override
			public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
				String name = method.getName();
				Object rtValue = null;
				try{
					//开启事务
					HibernateUtil.beginTransaction();					
					//执行操作
					rtValue = method.invoke(customerService, args);			
					//提交事务
					HibernateUtil.commit();
				}catch(Exception e){
					//回滚事务
					HibernateUtil.rollback();	
					e.printStackTrace();
				}finally{
					//释放资源.hibernate在我们事务操作（提交/回滚）之后，已经帮我们关了。
					//如果他没关，我们在此处关
				}
				return rtValue;
			}
		});
		return proxyCustomerService;
	}
}