黑马程序员--代理及AOP

----------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------     

          代理模式的主要作用是为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。　　代理模式的思想是为了提供额外的处理或者不同的操作而在实际对象与调用者之间插入一个代理对象。这些额外的操作通常需要与实际对象进行通信。

       动态代理 ：
      与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。

 静态代理：由程序员创建或特定工具自动生成源代码，再对其编译。在程序运行前，代理类的.class文件就已经存在了。

       AOP为Aspect Oriented Programming的缩写，意为：面向切面编程（也叫面向方面），可以通过预编译方式和运行期动态代理实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。

笔记：

ProxyTest.java

 

import java.lang.reflect.Constructor;

import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;

import java.util.ArrayList;

import java.util.Collection;

 

public class ProxyTest {

 

      public static void main(String[] args) throws Exception{

           //创建一个实现COllection接口的动态类，并查看其名称

           //getProxyClass(加载器，接口)

           Class clazzProxy1 = Proxy.getProxyClass(Collection.class.getClassLoader(), Collection.class);

           System.out.println(clazzProxy1.getName());

          

           System.out.println("----------begin constructors list----------");

           /*$Proxy0()

           $Proxy0(InvocationHandler,int)*/

           //得到构造方法

           Constructor[] constructors = clazzProxy1.getConstructors();

           for(Constructor constructor : constructors){

                 String name = constructor.getName();

                 //往字符串上面动态的添加内容，StringBuilder单线程上效率高，StringBuffer多线程上效率高

                 StringBuilder sBuilder = new StringBuilder(name);

                 sBuilder.append('(');

                 //得到所用的参数

                 Class[] clazzParams = constructor.getParameterTypes();

                 for(Class clazzParam : clazzParams){

                      sBuilder.append(clazzParam.getName()).append(',');

                 }

                 //如果没参数的时候就会删除那半个（ 需要判断一下 ）

                 if(clazzParams!=null && clazzParams.length != 0)

                      //去掉最后一个“，”号

                      sBuilder.deleteCharAt(sBuilder.length()-1);

                 sBuilder.append(')');

                 System.out.println(sBuilder.toString());               

           }

 

           System.out.println("----------begin methods list----------");

           /*$Proxy0()

           $Proxy0(InvocationHandler,int)*/

           //方法列表

           Method[] methods = clazzProxy1.getMethods();

           for(Method method : methods){

                 String name = method.getName();

                 StringBuilder sBuilder = new StringBuilder(name);

                 sBuilder.append('(');

                 Class[] clazzParams = method.getParameterTypes();

                 for(Class clazzParam : clazzParams){

                      sBuilder.append(clazzParam.getName()).append(',');

                 }

                 if(clazzParams!=null && clazzParams.length != 0)

                      sBuilder.deleteCharAt(sBuilder.length()-1);

                 sBuilder.append(')');

                 System.out.println(sBuilder.toString());               

           }

          

           System.out.println("----------begin create instance object----------");

           //Object obj = clazzProxy1.newInstance();  调用不带参数的构造方法，没有

//         创建实例对象  getConstructor()调用构造方法  InvocationHandler.class 参数的类型

           Constructor constructor = clazzProxy1.getConstructor(InvocationHandler.class);

           //InvocationHander 一个接口，创建一个实现接口的类

           class MyInvocationHander1 implements InvocationHandler{

 

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

                            throws Throwable {

                      // TODO Auto-generated method stub

                      return null;

                 }

           }

           //创建对象

           Collection proxy1 = (Collection)constructor.newInstance(new MyInvocationHander1());

          

           System.out.println(proxy1);

           proxy1.clear();

           //由于返回是null，所以此时会报错

           //proxy1.size();

           //System.out.println("111111111111111");

          

           //创建实例对象

           Collection proxy2 = (Collection)constructor.newInstance(new InvocationHandler(){

 

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

                            throws Throwable {

                      return null;

                 }

           });

          

           final ArrayList target = new ArrayList();              

           Collection proxy3 = (Collection)getProxy(target,new MyAdvice());

           proxy3.add("zxx");

           proxy3.add("lhm");

           proxy3.add("bxd");

           System.out.println(proxy3.size());

           System.out.println(proxy3.getClass().getName());

      }

 

      private static Object getProxy(final Object target,final Advice advice) {

           Object proxy3 = Proxy.newProxyInstance(

                      //第一个参数是类加载器

                      target.getClass().getClassLoader(),

                      /*new Class[]{Collection.class} 多个接口 ，数组的形式,*/

                      target.getClass().getInterfaces(),

                      //匿名内部类 一个实例对象

                      new InvocationHandler(){

                     

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

                                       throws Throwable {

 

                                  /*long beginTime = System.currentTimeMillis();

                                  Object retVal = method.invoke(target, args);

                                  long endTime = System.currentTimeMillis();

                                  System.out.println(method.getName() + " running time of " + (endTime - beginTime));

                                  return retVal;*/

 

                                  advice.beforeMethod(method);

                                  Object retVal = method.invoke(target, args);

                                  advice.afterMethod(method);

                                  return retVal;                            

                            }

                      }

                      );

           return proxy3;

      }

}

 

 

MyAdvice.java

 

import java.lang.reflect.Method;

 

public class MyAdvice implements Advice {

      long beginTime = 0;

      public void afterMethod(Method method) {

           // TODO Auto-generated method stub

           System.out.println("从传智播客毕业上班啦！");     

           long endTime = System.currentTimeMillis();

           System.out.println(method.getName() + " running time of " + (endTime - beginTime));

 

      }

 

      public void beforeMethod(Method method) {

           // TODO Auto-generated method stub

           System.out.println("到传智播客来学习啦！");

           beginTime = System.currentTimeMillis();

      }

}

 

 

Advice.java

 

import java.lang.reflect.Method;

 

public interface Advice {

      void beforeMethod(Method method);

      void afterMethod(Method method);

}

 

---------- android培训、java培训、java学习型技术博客、期待与您交流！ ------------