Spring04
Spring AOP
AOP用于将那些与业务无关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。
AOP的引入
业务需求：完成用户功能的处理代码
系统需求：日志，安全，事务等
如果把系统需求加入到处理业务需求的类中，那么业务类就会变得很复杂和零乱。甚至可能会喧宾夺主，而且以后要变更系统需求的时候，将给软件带来很大的维护量
日志功能
- 代码混乱：越来越多的非业务需求(日志和验证等)加入后,原有的业务方法急剧膨胀.每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点
- 代码分散：以日志需求为例,只是为了满足这个单一需求,就不得不在多个模块（方法）里多次重复相同的日志代码.如果日志需求发生变化,必须修改所有模块
核心业务功能（例如登录）横切系统功能（例如记录日志）
1、继承=Java中的单根继承
2、工具类=耦合
3、代理模式
代理模式
在代理模式Proxy Pattern中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上
Spring AOP使用的动态代理，属于运行时增强。所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
优点
- 能够协调调用者和被调用者，在一定程度上降低了系统的耦合度
- 客户端可以针对抽象类进行编程，增加和更换代理类无须修改源代码，符合开闭原则，系统具有较好的灵活性和可扩展性
缺点
- 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢
实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
注意事项
- 和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口
- 和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。
代理模式
代理模式一般可以分为静态代理和动态代理两种
静态代理
代理代码是由自己去编写固定的代码，缺点很明显，静态代理只能服务于一种类型的对象，不利于业务的扩展
interface 接口{}
class 具体实现 implements 接口{}
class 代理实现 implements 接口{
private 接口 被代理对象;
}
动态代理
它是用反射机制动态的生成代理的对象，不需要知道谁代理谁
动态代理具体实现有2种方式：JDK动态代理和CGLib动态代理
JDK动态代理是依靠反射机制实现的，且面向接口
InvocationHandler接口，未来调用代理对象的任何方法实际上都是在调用InvocationHandler接口中的方法
Proxy类用于生成代理对象，代理对象没有具体的实现类
代理模式总结
代理模式一般可以分为静态代理和动态代理两种
静态代理，代理代码是由自己去编写固定的代码，缺点很明显，静态代理只能服务于一种类型的对象，不利于业务的扩展
动态代理，它是用反射机制动态的生成代理的对象，不需要知道谁代理谁
AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理,在不修改源代码的情况下给程序增加动态控制功能的一种技术
-
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率
-
AOP采取横向抽取机制，取代了传统纵向继承体系重复性代码，实际上是OOP的一种补充，不存在谁体态谁的问题
-
经典应用：事务管理、性能监视、安全检查、缓存、日志等
登录处理流程
Servlet–>Service–>DAO -->Database
Filter
filterChain.doFilter(request,response); -
Spring AOP使用纯Java实现，不需要专门的编译过程和类加载器，在运行期通过代理方式向目标类织入增强代码
- 代理模式——默认使用的是JDK的动态代理，同时也可以支持CGLib的动态代理
- JDK的动态代理要求必须有对应的接口，但是CGLib的代理不需要接口
-
AspectJ是一个基于Java语言的AOP框架，Spring2.0开始，Spring AOP引入对Aspect的支持，AspectJ扩
展了Java语言，提供了一个专门的编译器，在编译时提供横向代码的织入
分散关注的思路
- 将通用需求功能从不相关类之中分离出来
- 能够使得很多类共享一个行为，一旦行为发生变化，不必修改很多类，只要修改这个行为就可以
- AOP就是这种实现分散关注的编程方法，它将“关注”封装在“方面”中
- 具体应用中Filter、Interceptor等都是AOP的实现
AOP实现原理
- spring的aop底层将采用代理机制进行实现
- SpringAOP的基本原理就是动态代理机制，将AOP编程的代价降到最低
- 接口 + 实现类 ：spring采用jdk的动态代理Proxy
- 没有接口只有实现类：spring采用CGlib字节码增强
面试================================================
JDK动态代理具体实现原理：
- 通过实现InvocationHandler接口创建自己的调用处理器；
- 通过为Proxy类指定ClassLoader对象和一组interface来创建动态代理；
- 通过反射机制获取动态代理类的构造函数，其唯一参数类型就是调用处理器接口类型；
- 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数参入；
public class 回调方法 implements InvocationHandler {
private 歌星 target;
public 回调方法(歌星 target){
this.target=target;
}
@Override
//调用代理对象的任何方法时，实际上都是这姓invoke这个方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("签订演艺合同....");
Object res=method.invoke(this.target,args); //调用具体被代理对象中的方法
System.out.println("收钱收钱~~~");
return res;
}
}
//反射包中的Proxy类提供了静态方法用于创建对应的代理对象.参数1是对应的类加载器，参数2为Class[]类型，指定代理的接口，参数3为InvocationHandler,是调用代理对象中的方法时的回调处理 歌星 proxy= (歌星) Proxy.newProxyInstance(歌星.class.getClassLoader(),new Class[]{歌星.class},new 回调方法(obj));proxy.唱歌(); — InvocationHandler中的invoke
JDK动态代理是面向接口的代理模式，如果被代理目标没有接口那么Spring也无能为力，Spring通过Java的反射机制生产被代理接口的新的匿名实现类，重写了其中AOP的增强方法。
CGLib动态代理
CGLib是一个强大、高性能的Code生产类库，可以实现运行期动态扩展java类，Spring在运行期间通过CGlib继承要被动态代理的类，重写父类的方法，实现AOP面向切面编程。
两者对比
- JDK动态代理是面向接口的。
- CGLib动态代理是通过字节码底层继承要代理类来实现（如果被代理类被final关键字所修饰，那么抱歉会失败）。
使用注意事项
- 如果要被代理的对象是个实现类，那么Spring会使用JDK动态代理来完成操作（Spirng默认采用JDK动态代理实现机制）；
- 如果要被代理的对象不是个实现类那么Spring会强制使用CGLib来实现动态代理。
教科书答案
- CGLib所创建的动态代理对象在实际运行时候的性能要比JDK动态代理高不少，有研究表明，大概要高10倍；
- 但是CGLib在创建对象的时候所花费的时间却比JDK动态代理要多很多，有研究表明，大概有8倍的差距；
- 因此，对于singleton的代理对象或者具有实例池的代理，因为无需频繁的创建代理对象，所以比较适合采用CGLib动态代理，反正，则比较适用JDK动态代理。经过多次试验，JDK动态代理的运行速度已经逐渐提高了，在低版本的时候，运行的性能可能不如CGLib【2倍】，但是在1.8版本中运行多次，基本都可以得到一致的测试结果，那就是JDK动态代理已经比CGLib动态代理快了[大致2倍]！
AOP术语
- Joinpoint连接点：程序执行过程中的某个特定的点
- Advice通知：在某个特定的Joinpoint上切面执行的动作
- Aspect切面：横切多个对象的关注点的模块化
- Pointcut切入点：符合某种规则的连接点
- AOP代理：AOP框架创建的对象，用来代理我们的目标对象
使用Spring框架的AOP
1、添加依赖 spring-aop spring-aspects和IoC容器依赖spring-context-support
2、业务接口
public interface 歌星 {
public void 唱歌();
}
3、添加对应的业务实现
public class 刘德华 implements 歌星{
@Override
public void 唱歌() {
System.out.println("冷冷的冰雨冷松的拍~~~~");
}
}
4、定义前置处理，需要在具体的业务逻辑处理之前执行的逻辑
public class 前置处理 implements MethodBeforeAdvice {
@Override
public void before(Method method, Object[] args, Object target) throws Throwable {
System.out.println("所调用的方法:"+method);
if(args!=null && args.length>0)
System.out.println("调用方法的参数:"+args);
else
System.out.println("方法没有参数");
System.out.println("目标对象:"+target);
System.out.println("签订演艺合同-----");
}
}
5、在IoC容器中申明
<bean id="gexing" class="com.yan1.aop.刘德华"/>
<bean id="lanjie" class="com.yan1.aop.前置处理"/>
<bean id="daili" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="interfaces">
<value>com.yan1.aop.歌星value>
property>
<property name="interceptorNames">
<value>lanjievalue>
property>
<property name="target" ref="gexing"/>
bean>
6、调用
获取IoC容器的引用
ApplicationContext ac=new ClassPathXmlApplicationContext(“aop/beans.xml”);
获取代理对象
歌星 obj= (歌星) ac.getBean(“daili”);
obj.唱歌();
在代理模式Proxy Pattern中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。
宋喆–>刘德华
public class 宋喆 implements 歌星 {
private 歌星 target;//被代理的对象
代理设计模式的原理: 使用一个代理将对象包装起来, 然后用该代理对象取代原始对象. 任何对原始对象的调用都要通过代理. 代理对象决定是否以及何时将方法调用转到原始对象上
歌星 obj1=new 刘德华(); //被代理对象
歌星 obj2=new 宋喆(obj1); //使用一个代理将对象包装起来
Spring AOP使用的动态代理，属于运行时增强。所谓的动态代理就是说AOP框架不会去修改字节码，而是每次运行时在内存中临时为方法生成一个AOP对象，这个AOP对象
包含了目标对象的全部方法，并且在特定的切点做了增强处理，并回调原对象的方法。
优点
- 能够协调调用者和被调用者，在一定程度上降低了系统的耦合度
- 客户端可以针对抽象类进行编程，增加和更换代理类无须修改源代码，符合开闭原则，系统具有较好的灵活性和可扩展性
缺点
- 由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢
实现代理模式需要额外的工作，有些代理模式的实现非常复杂。
注意事项
- 和适配器模式的区别：适配器模式主要改变所考虑对象的接口，而代理模式不能改变所代理类的接口
- 和装饰器模式的区别：装饰器模式为了增强功能，而代理模式是为了加以控制。
接口
具体实现–被代理对象
代理实现–代理对象
代理缺点：不灵活，以后修改了接口代理类也要维护；而且代理的类型受到接口的制约，但是事务基本所有的业务逻辑模块都有，所以此方法不易推广。