Spring---Aop详解

目录·
1、AOP 什么？
· 2、需求·
3、解决办法1:使用静态代理·
4、解决办法2：使用JDK动态代理 ·
 5、AOP 关键术语　·
  6、AOP 的通知类型　　·
  7、使用 Spring AOP 解决上面的需求这章我们接着讲 Spring 的核心概念—AOP，这也是 Spring 框架中最为核心的一个概念。
  1、AOP 什么？　
  　AOP（Aspect Oriented Programming），通常称为面向切面编程。它利用一种称为"横切"的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其命名为"Aspect"，即切面。所谓"切面"，简单说就是那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块之间的耦合度，并有利于未来的可操作性和可维护性。什么是切面，什么是公共模块，那么我们概念少说，直接通过一个实例来看看 AOP 到底是什么。
  　2、需求
  　现在有一张表 User,然后我们要在程序中实现对 User 表的增加和删除操作。　
  　　要求：增加和删除操作都必须要开启事务，操作完成之后要提交事务。　
  　　　User.java`

package com.ys.aop.one; public class User {
  　　　private int uid;
  　　　private String uname;
  　　　 public int getUid() { return uid; }
  　　　 public void setUid(int uid) { this.uid = uid; } public String getUname() { return uname; }
  　　　 public void setUname(String uname) { this.uname = uname; } }

package com.ys.aop.one; public class User {
private int uid;
private String uname;
public int getUid() {
return uid; }
public void setUid(int uid) {
this.uid = uid; }
public String getUname() {
return uname; }
public void setUname(String uname) {
this.uname = uname; } }

      @Test  
        public void testOne(){     
           MyTransaction transaction = new MyTransaction();      
          UserService userService = new UserServiceImpl();    
              //产生静态代理对象       
               ProxyUser proxy = new ProxyUser(userService, transaction);        		proxy.addUser(null);     
                  proxy.deleteUser(0);  
                    }
                    **这是一个很基础的静态代理，业务类UserServiceImpl 只需要关注业务逻辑本身，保证了业务的重用性，这也是代理类的优点，没什么好说的。我们主要说说这样写的缺点：　　①、代理对象的一个接口只服务于一种类型的对象，如果要代理的方法很多，势必要为每一种方法都进行代理，静态代理在程序规模稍大时就无法胜任了。②、如果接口增加一个方法，比如 UserService 增加修改 updateUser(）方法，则除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。**
       使用JDK动态代理  
       　　动态代理就不要自己手动生成代理类了，我们去掉 ProxyUser.java 类，增加一个 ObjectInterceptor.java 类
       　　pscksge com.ys.aop.two; import 	
       　　import java.lang.reflect.InvocationHandler;
       　　import java.lang.reflect.Method;import java.lang.reflect.Proxy; 
       　　import com.ys.aop.one.MyTransaction;
       　　 public class ObjectInterceptor implements InvocationHandler{    
       　　 //目标类    private Object target;  
       　　   //切面类（这里指事务类）    private MyTransaction transaction;         
       　　   //通过构造器赋值   
       　　    public ObjectInterceptor(Object target,MyTransaction transaction){      
       　　      this.target = target;     
       　　         this.transaction = transaction;    }      
       　　            @Override    
       　　            public Object invoke(Object proxy, Method method, Object[] args)  throws Throwable {    
       　　                //开启事务        this.transaction.before();     
       　　                   //调用目标类方法        method.invoke(this.target, args);      
       　　                     //提交事务        this.transaction.after();        return null;    }     }　
       　　                     　测试：
       　　                     @Test    public void testOne(){   
       　　                          //目标类       
       　　                           Object target = new UserServiceImpl();     
       　　                              //事务类     
       　　          MyTransaction transaction = new MyTransaction();    
       　　                                     ObjectInterceptor proxyObject = new ObjectInterceptor(target, transaction);       
       　　                                      /**         * 三个参数的含义：      
       　　                                         * 1、目标类的类加载器         
       　　                                         * 2、目标类所有实现的接口      
       　　                                            * 3、拦截器         */       
       　　                                             UserService userService = (UserService) Proxy.newProxyInstance(target.getClass().getClassLoader(),       target.getClass().getInterfaces(), proxyObject);        
       　　                         userService.addUser(null); 
       　　                                                }
       　　                                                **

也就是做到了代理对象能够代理多个目标类，多个目标方法。

** 5、AOP 关键术语　　
　 1.target：目标类，需要被代理的类。例如：UserService　　 2.Joinpoint(连接点):所谓连接点是指那些可能被拦截到的方法。例如：所有的方法　
　　3.PointCut 切入点：已经被增强的连接点。例如：addUser()　　
　　4.advice 通知/增强，增强代码。例如：after、before　
　　5. Weaving(织入):是指把增强advice应用到目标对象target来创建新的代理对象proxy的过程.　
　　6.proxy 代理类：通知+切入点　
　　7. Aspect(切面): 是切入点pointcut和通知advice的结合
　　
6、AOP 的通知类型　　
　　Spring按照通知Advice在目标类方法的连接点位置，可以分为5类·
　　前置通知 org.springframework.aop.MethodBeforeAdvice· 在目标方法执行前实施增强，比如上面例子的 before()方法·
　　 后置通知 org.springframework.aop.AfterReturningAdvice· 在目标方法执行后实施增强，比如上面例子的 after()方法
　　 · 环绕通知 org.aopalliance.intercept.MethodInterceptor· 在目标方法执行前后实施增强·
　　 异常抛出通知 org.springframework.aop.ThrowsAdvice· 在方法抛出异常后实施增强·
　　 引介通知 org.springframework.aop.IntroductionInterceptor　　　　　　在目标类中添加一些新的方法和属性