aop简单了解

aop就是面向切面的编程。是一种编程的思想，将日志记录，性能统计，安全控制，事务处理，异常处理等等代码从业务逻辑代码中划分出来，通过对这些行为的分离，独立到非业务逻辑代码中，进而改变这些行为的时候不影响业务逻辑的代码。aop只是一种思想和范式，并没有要求具体用什么方法去实现。

实现aop可以用代理实现，有动态代理和静态代理，静态代理：在程序运行前，代理类的.class文件就已经存在了。动态代理类：在程序运行时，运用反射机制动态创建而成。

静态代理：

静态代理的例子：

public class UserControllerProxy implements  UserController{

     // 目标对象 

     private UserController userController;

     // 通过构造方法传入目标对象  

     public UserControllerProxy (UserController userControuller ){  

           this.userControuller =userControuller ;  

     }

    public void saveUser() {

        checkAuth();

        userController.saveUser();

    }

}

UserControllerProxy 去代理UserController的saveUser()方法，在save时进行相关处理。

静态代理类优缺点

优点：

代理使客户端不需要知道实现类是什么，怎么做的，而客户端只需知道代理即可（解耦合），对于如上的客户端代码，newUserManagerImpl()可以应用工厂将它隐藏，如上只是举个例子而已。

缺点：

1）代理类和委托类实现了相同的接口，代理类通过委托类实现了相同的方法。这样就出现了大量的代码重复。如果接口增加一个方法，除了所有实现类需要实现这个方法外，所有代理类也需要实现此方法。增加了代码维护的复杂度。

2）代理对象只服务于一种类型的对象，如果要服务多类型的对象。势必要为每一种对象都进行代理，静态代理在程序规模稍大时就无法胜任了。如上的代码是只为UserManager类的访问提供了代理，但是如果还要为其他类如Department类提供代理的话，就需要我们再次添加代理Department的代理类。

动态代理：

在Java中要想实现动态代理机制，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy 类的支持

静态代理的例子：

代理类：

//动态代理类只能代理接口（不支持抽象类），代理类都需要实现InvocationHandler类，实现invoke方法。该invoke方法就是调用被代理接口的所有方法时需要调用的，该invoke方法返回的值是被代理接口的一个实现类  

     

public class LogHandler implements InvocationHandler {  

  

    // 目标对象  

    private Object targetObject;  

    //绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。              

    public Object newProxyInstance(Object targetObject){  

        this.targetObject=targetObject;  

        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    

       //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  

        //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  

        //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  

        //根据传入的目标返回一个代理对象  

        return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),  

                targetObject.getClass().getInterfaces(),this);  

    }  

    @Override  

    //关联的这个实现类的方法被调用时将被执行  

    /*InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数*/  

    public Object invoke(Object proxy, Method method, Object[] args)  

            throws Throwable {  

        System.out.println("start-->>");  

        for(int i=0;i<args.length;i++){  

            System.out.println(args[i]);  

        }  

        Object ret=null;  

        try{  

            /*原对象方法调用前处理日志信息*/  

            System.out.println("satrt-->>");  

            //调用目标方法  

            ret=method.invoke(targetObject, args);  

            /*原对象方法调用后处理日志信息*/  

            System.out.println("success-->>");  

        }catch(Exception e){  

            e.printStackTrace();  

            System.out.println("error-->>");  

            throw e;  

        }  

        return ret;  

    }  

}  

被代理对象targetObject通过参数传递进来，我们通过targetObject.getClass().getClassLoader()获取ClassLoader对象，然后通过targetObject.getClass().getInterfaces()获取它实现的所有接口，然后将targetObject包装到实现了InvocationHandler接口的LogHandler对象中。通过newProxyInstance函数我们就获得了一个动态代理对象。

调用代理类：

public class Client {  

  

    public static void main(String[] args){  

        LogHandler logHandler=new LogHandler();  

        UserManager userManager=(UserManager)logHandler.newProxyInstance(new UserManagerImpl());  

        //UserManager userManager=new UserManagerImpl();  

        userManager.addUser("1111", "张三");  

    }  

}  

动态代理优点：

动态代理与静态代理相比较，最大的好处是接口中声明的所有方法都被转移到调用处理器一个集中的方法中处理（InvocationHandler.invoke）。这样，在接口方法数量比较多的时候，我们可以进行灵活处理，而不需要像静态代理那样每一个方法进行中转。而且动态代理的应用使我们的类职责更加单一，复用性更强。

 

当然这些例子都是为了好理解所以使用了这种方式，其实动态代理可以写成一个注解，然后在你的方法上加上注解就可以了，不需要再调用代理类。