精华内容
下载资源
问答
  • 动态代理实现新增add 打印日志 public class ArrayListInvocationHandler implements InvocationHandler { Object list=null; public ArrayListInvocationHandler(Object list){ this.list=list; } ...

    1.什么是动态代理

    一种用于转发请求,进行特殊处理的机制,“动态”应该指的是“运行期”。 

    2.为什么使用动态代理

    可以对请求进行任何处理(如事务,日志等,这都是网上说的,我当然可以做任何处理) 

    3.使用动态代理有什么好处

    可以对请求进行任何处理(如事务,日志等,这都是网上说的,我当然可以做任何处理) 

    4.哪些地方需要动态代理

    不允许直接访问某些类;对访问要做特殊处理等,我只能想到这些。

    为什么代理只能代理接口

    因为所有生成的代理已经继承自Proxy,如果再继承,不符合java规范,不允许存在多继承


    动态代理实现新增add 打印日志

    public class ArrayListInvocationHandler implements InvocationHandler {
    		
    	Object list=null;
    	
    	public ArrayListInvocationHandler(Object list){
    		this.list=list;
    	}
    	
    	public Object getProxy(){
    		return Proxy.newProxyInstance(this.getClass().getClassLoader(), list.getClass().getInterfaces(),this);
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {

    if(method.getName().equals("add"))

    System.out.println(list.getClass().getName()+":before add");

    Object temp=method.invoke(list, args); return temp; } }



    public class ArrayListProxyTest {
    	public static void main(String[] args) {
    		ArrayListInvocationHandler handler=new ArrayListInvocationHandler(new LinkedList<String>());
    		List<String> list=(List<String>)handler.getProxy();
    		list.add("abc");
    	}
    }



    转载于:https://my.oschina.net/u/1186493/blog/179617

    展开全文
  • 创建动态代理的步骤:   1.创建一个实现接口InvocationHandler的类,它必须实现invoke方法 2.创建被代理的类以及接口 3.通过Proxy的静态方法 newProxyInstance(ClassLoader loader, Class[] interfaces, ...

     

    创建动态代理的步骤:

     

    1.创建一个实现接口InvocationHandler的类,它必须实现invoke方法

    2.创建被代理的类以及接口

    3.通过Proxy的静态方法

    newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个代理

    4.通过代理调用方法

     

    所谓Dynamic Proxy是这样一种class:

    它是在运行时生成的class,在生成它时你必须提供一组interface给它,然后该class就宣称它实现了这些interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然,这个Dynamic Proxy其实就是一个Proxy,它不会替你作实质性的工作,在生成它的实例时你必须提供一个handler,由它接管实际的工作

     

     

     

    package com.zj.dynamicproxy2;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    /**代理处理器
     * @author zhengjiong
     * time:2011-9-22 下午06:20:57
     */
    public class DynamicProxy implements InvocationHandler
    {
    	private Object obj;
    	
    	public DynamicProxy(Object obj)
    	{
    		this.obj = obj;
    	}
    	
    	public static Object factory(Object object)
    	{
    		Object Obj = Proxy.newProxyInstance(object.getClass().getClassLoader(),
    				object.getClass().getInterfaces(), new DynamicProxy(object));
    		
    		return Obj;
    	}
    	
    	
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable
    	{
    		if(null != args)
    		{
    			for(Object obj : args)
    			{
    				System.out.println("args: " + obj);
    			}
    		}
    		
    		System.out.println("before method!: " + method);
    		
    		Object returnValue = method.invoke(obj, args);
    		
    		System.out.println("after method!: " + method);
    		System.out.println("-------------------------");
    		return returnValue;
    	}
    	
    }
    

     

     

     

    package com.zj.dynamicproxy2;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    import java.util.ArrayList;
    import java.util.List;
    
    public class Test
    {
    	public static void main(String[] args)
    	{
    		
    		List list1 = new ArrayList();
    		
    		List listProxy = (List)DynamicProxy.factory(list1);
    		
    		listProxy.add("zhengjiong");
    		
    		
    	}
    }
    
    展开全文
  • public class ArrayListProxy { public static void main(String[] args) { final ArrayList target = new ArrayList(); List proxy = (List)Proxy.newProxyInstance( List. c...
    public class ArrayListProxy {
        public static void main(String[] args) {
            final ArrayList target = new ArrayList();
            List proxy = (List)Proxy.newProxyInstance(
                    List. class.getClassLoader(),
                    ArrayList. class.getInterfaces(),
                    new InvocationHandler(){
                        public Object invoke(Object proxy , Method method, Object[] args)
                                throws Throwable{
                            Long beginTime = System.currentTimeMillis();
                            Thread. sleep(10);
                            Object reVal = method.invoke( target, args);
                            long endTime = System.currentTimeMillis ();
    
                            System. out.println(method .getName() + " runing time is :" + (endTime - beginTime));
                            return reVal ;
                        }
                    });
    
            proxy.add("测试——1");
            proxy.add("测试——2");
            proxy.add("测试——3");
            proxy.add("测试——4");
            System. out.println(proxy .toString());
    
        }
    
    }
    展开全文
  • Java试题-2:ArrayList动态代理 什么是动态代理 动态代理该怎么实现
  • newarrayList = arrayList.stream().distinct().collect(Collectors.toList());  ArrayList&lt;String&gt; newarrayList = new ArrayList&lt;String&gt;(new HashSet&lt;String&gt;(arr.....

    //List<Object> newarrayList = arrayList.stream().distinct().collect(Collectors.toList());
            ArrayList<String> newarrayList = new ArrayList<String>(new HashSet<String>(arrayList)); 

     反射,当时经常听他们说,自己也看过一些资料,也可能在设计模式中使用过,但是感觉对它没有一个较深入的了解,这次重新学习了一下,感觉还行吧!

     

               一,先看一下反射的概念:

                  主要是指程序可以访问,检测和修改它本身状态或行为的一种能力,并能根据自身行为的状态和结果,调整或修改应用所描述行为的状态和相关的语义。

                 反射是java中一种强大的工具,能够使我们很方便的创建灵活的代码,这些代码可以再运行时装配,无需在组件之间进行源代码链接。但是反射使用不当会成本很高!

                 看概念很晕的,继续往下看。

     

          二,反射机制的作用:

                  1,反编译:.class-->.java

                  2,通过反射机制访问java对象的属性,方法,构造方法等;

                 这样好像更容易理解一些,下边我们具体看怎么实现这些功能。

     

          三,在这里先看一下sun为我们提供了那些反射机制中的类:

    java.lang.Class;                

    java.lang.reflect.Constructor; java.lang.reflect.Field;        

    java.lang.reflect.Method;

    java.lang.reflect.Modifier;

     

                很多反射中的方法,属性等操作我们可以从这四个类中查询。还是哪句话要学着不断的查询API,那才是我们最好的老师。

     

             四,具体功能实现:

                    1,反射机制获取类有三种方法,我们来获取Employee类型

     

    [java] view plain copy  print?

    1. //第一种方式:  
    2. Classc1 = Class.forName("Employee");  
    3. //第二种方式:  
    4. //java中每个类型都有class 属性.  
    5. Classc2 = Employee.class;  
    6.    
    7. //第三种方式:  
    8. //java语言中任何一个java对象都有getClass 方法  
    9. Employeee = new Employee();  
    10. Classc3 = e.getClass(); //c3是运行时类 (e的运行时类是Employee)  

     

     

     

     

        2,创建对象:获取类以后我们来创建它的对象,利用newInstance:

     

    [java] view plain copy  print?

    1. Class c =Class.forName("Employee");  
    2.   
    3. //创建此Class 对象所表示的类的一个新实例  
    4. Objecto = c.newInstance(); //调用了Employee的无参数构造方法.  

     

     

     

     

     

        3,获取属性:分为所有的属性和指定的属性:

          a,先看获取所有的属性的写法:

     

    [java] view plain copy  print?

    1. //获取整个类  
    2.             Class c = Class.forName("java.lang.Integer");  
    3.               //获取所有的属性?  
    4.             Field[] fs = c.getDeclaredFields();  
    5.        
    6.                    //定义可变长的字符串,用来存储属性  
    7.             StringBuffer sb = new StringBuffer();  
    8.             //通过追加的方法,将每个属性拼接到此字符串中  
    9.             //最外边的public定义  
    10.             sb.append(Modifier.toString(c.getModifiers()) + " class " + c.getSimpleName() +"{\n");  
    11.             //里边的每一个属性  
    12.             for(Field field:fs){  
    13.                 sb.append("\t");//空格  
    14.                 sb.append(Modifier.toString(field.getModifiers())+" ");//获得属性的修饰符,例如public,static等等  
    15.                 sb.append(field.getType().getSimpleName() + " ");//属性的类型的名字  
    16.                 sb.append(field.getName()+";\n");//属性的名字+回车  
    17.             }  
    18.       
    19.             sb.append("}");  
    20.       
    21.             System.out.println(sb);  


           b,获取特定的属性,对比着传统的方法来学习:

     

     

     

     

     

    [java] view plain copy  print?

    1. public static void main(String[] args) throws Exception{  
    2.               
    3. <span style="white-space:pre">  </span>//以前的方式:  
    4.     /* 
    5.     User u = new User(); 
    6.     u.age = 12; //set 
    7.     System.out.println(u.age); //get 
    8.     */  
    9.               
    10.     //获取类  
    11.     Class c = Class.forName("User");  
    12.     //获取id属性  
    13.     Field idF = c.getDeclaredField("id");  
    14.     //实例化这个类赋给o  
    15.     Object o = c.newInstance();  
    16.     //打破封装  
    17.     idF.setAccessible(true); //使用反射机制可以打破封装性,导致了java对象的属性不安全。  
    18.     //给o对象的id属性赋值"110"  
    19.     idF.set(o, "110"); //set  
    20.     //get  
    21.     System.out.println(idF.get(o));  
    22. }  

     

     

     

     4,获取方法,和构造方法,不再详细描述,只来看一下关键字:

    方法关键字

    含义

    getDeclaredMethods()

    获取所有的方法

    getReturnType()

    获得方法的放回类型

    getParameterTypes()

    获得方法的传入参数类型

    getDeclaredMethod("方法名",参数类型.class,……)

    获得特定的方法

     

     

    构造方法关键字

    含义

    getDeclaredConstructors()

    获取所有的构造方法

    getDeclaredConstructor(参数类型.class,……)

    获取特定的构造方法

     

     

    父类和父接口

    含义

    getSuperclass()

    获取某类的父类

    getInterfaces()

    获取某类实现的接口

      

    public Method getDeclaredMethod(String name,
                                    Class<?>... parameterTypes)
                             throws NoSuchMethodException,
                                    SecurityException

    返回一个 Method 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明方法。name 参数是一个String,它指定所需方法的简称,parameterTypes 参数是Class 对象的一个数组,它按声明顺序标识该方法的形参类型。如果在某个类中声明了带有相同参数类型的多个方法,并且其中有一个方法的返回类型比其他方法的返回类型都特殊,则返回该方法;否则将从中任选一个方法。如果名称是 "<init>” 或 “<clinit>",则引发一个NoSuchMethodException

     

    参数:

    name - 方法名

    parameterTypes - 参数数组

    返回:

    该类与指定名和参数相匹配的方法的 Method 对象

    抛出:

    NoSuchMethodException - 如果找不到匹配的方法。

    NullPointerException - 如果namenull

    SecurityException - 如果存在安全管理器s,并满足下列任一条件:

     

     

    public Field getDeclaredField(String name)
                           throws NoSuchFieldException,
                                  SecurityException

    返回一个 Field 对象,该对象反映此 Class 对象所表示的类或接口的指定已声明字段。name 参数是一个String,它指定所需字段的简称。注意,此方法不反映数组类的length 字段。

     

    参数:

    name - 字段名

    返回:

    此类中指定字段的 Field 对象

    抛出:

    NoSuchFieldException - 如果找不到带有指定名称的字段。

    NullPointerException - 如果namenull

    SecurityException - 如果存在安全管理器s,并满足下列任一条件:

    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
                                          throws NoSuchMethodException,
                                                 SecurityException

    返回一个 Constructor 对象,该对象反映此 Class 对象所表示的类或接口的指定构造方法。parameterTypes 参数是Class 对象的一个数组,它按声明顺序标识构造方法的形参类型。 如果此Class 对象表示非静态上下文中声明的内部类,则形参类型作为第一个参数包括显示封闭的实例。

     

    参数:

    parameterTypes - 参数数组

    返回:

    带有指定参数列表的构造方法的 Constructor 对象

    抛出:

    NoSuchMethodException - 如果找不到匹配的方法。

    SecurityException - 如果存在安全管理器s,并满足下列任一条件:

     

     

     

    首先得根据传入的类的全名来创建Class对象。 
        Class c=Class.forName("className");注明:className必须为全名,也就是得包含包名,比如,cn.netjava.pojo.UserInfo; 

        也可以使用:对象名.getClass();或者类名.class

       Object obj=c.newInstance();//创建对象的实例 

        OK,有了对象就什么都好办了,想要什么信息就有什么信息了。   
        获得构造函数的方法 
        Constructor getConstructor(Class[] params)//根据指定参数获得public构造器

        Constructor[] getConstructors()//获得public的所有构造器

        Constructor getDeclaredConstructor(Class[] params)//根据指定参数获得public和非public的构造器

        Constructor[] getDeclaredConstructors()//获得public的所有构造器 
        获得类方法的方法 
        Method getMethod(String name, Class[] params),根据方法名,参数类型获得方法

        Method[] getMethods()//获得所有的public方法

        Method getDeclaredMethod(String name, Class[] params)//根据方法名和参数类型,获得public和非public的方法

        Method[] getDeclaredMethods()//获得所以的public和非public方法 
        获得类中属性的方法 
        Field getField(String name)//根据变量名得到相应的public变量

        Field[] getFields()//获得类中所以public的方法

        Field getDeclaredField(String name)//根据方法名获得public和非public变量

        Field[] getDeclaredFields()//获得类中所有的public和非public方法 

     

             这样我们就可以获得类的各种内容,进行了反编译。对于JAVA这种先编译再运行的语言来说,反射机制可以使代码更加灵活,更加容易实现面向对象。

     

     

      五,反射加配置文件,使我们的程序更加灵活:

                 在设计模式学习当中,学习抽象工厂的时候就用到了反射来更加方便的读取数据库链接字符串等,当时不是太理解,就照着抄了。看一下.NET中的反射+配置文件的使用:

                 当时用的配置文件是app.config文件,内容是XML格式的,里边填写链接数据库的内容:

     

    [html] view plain copy  print?

    1.       <configuration>  
    2. lt;appSettings>  
    3. <add     key=""  value=""/>  
    4. lt;/appSettings>  
    5.         </configuration>  

     

     

     

     反射的写法:   

     

    [csharp] view plain copy  print?

    1. assembly.load("当前程序集的名称").CreateInstance("当前命名空间名称".要实例化的类名);  

     

     

     

     

              这样的好处是很容易的方便我们变换数据库,例如我们将系统的数据库从SQL Server升级到Oracle,那么我们写两份D层,在配置文件的内容改一下,或者加条件选择一下即可,带来了很大的方便。

                

             当然了,JAVA中其实也是一样,只不过这里的配置文件为.properties,称作属性文件。通过反射读取里边的内容。这样代码是固定的,但是配置文件的内容我们可以改,这样使我们的代码灵活了很多!

     

     AOP的拦截功能是由java中的动态代理来实现的。说白了,就是在目标类的基础上增加切面逻辑,生成增强的目标类(该切面逻辑或者在目标类函数执行之前,或者目标类函数执行之后,或者在目标类函数抛出异常时候执行。不同的切入时机对应不同的Interceptor的种类,如BeforeAdviseInterceptor,AfterAdviseInterceptor以及ThrowsAdviseInterceptor等)。

     

    那么动态代理是如何实现将切面逻辑(advise)织入到目标类方法中去的呢?下面我们就来详细介绍并实现AOP中用到的两种动态代理。

    AOP的源码中用到了两种动态代理来实现拦截切入功能:jdk动态代理和cglib动态代理。两种方法同时存在,各有优劣。jdk动态代理是由java内部的反射机制来实现的,cglib动态代理底层则是借助asm来实现的。总的来说,反射机制在生成类的过程中比较高效,而asm在生成类之后的相关执行过程中比较高效(可以通过将asm生成的类进行缓存,这样解决asm生成类过程低效问题)。还有一点必须注意:jdk动态代理的应用前提,必须是目标类基于统一的接口。如果没有上述前提,jdk动态代理不能应用。由此可以看出,jdk动态代理有一定的局限性,cglib这种第三方类库实现的动态代理应用更加广泛,且在效率上更有优势。。

    1、定义接口和实现

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.service;  
    2.   
    3.   
    4. public interface UserService {  
    5.     public String getName(int id);  
    6.   
    7.     public Integer getAge(int id);  
    8. }  

     

     

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.service.impl;  
    2.   
    3. import com.meituan.hyt.test3.service.UserService;  
    4.   
    5.   
    6. public class UserServiceImpl implements UserService {  
    7.     @Override  
    8.     public String getName(int id) {  
    9.         System.out.println("------getName------");  
    10.         return "Tom";  
    11.     }  
    12.   
    13.     @Override  
    14.     public Integer getAge(int id) {  
    15.         System.out.println("------getAge------");  
    16.         return 10;  
    17.     }  
    18. }  

     

     

     

    2、jdk动态代理实现

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.jdk;  
    2.   
    3. import java.lang.reflect.InvocationHandler;  
    4. import java.lang.reflect.Method;  
    5.   
    6.   
    7. public class MyInvocationHandler implements InvocationHandler {  
    8.     private Object target;  
    9.   
    10.     MyInvocationHandler() {  
    11.         super();  
    12.     }  
    13.   
    14.     MyInvocationHandler(Object target) {  
    15.         super();  
    16.         this.target = target;  
    17.     }  
    18.   
    19.     @Override  
    20.     public Object invoke(Object o, Method method, Object[] args) throws Throwable {  
    21.         if("getName".equals(method.getName())){  
    22.             System.out.println("++++++before " + method.getName() + "++++++");  
    23.             Object result = method.invoke(target, args);  
    24.             System.out.println("++++++after " + method.getName() + "++++++");  
    25.             return result;  
    26.         }else{  
    27.             Object result = method.invoke(target, args);  
    28.             return result;  
    29.         }  
    30.   
    31.     }  
    32. }  

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.jdk;  
    2.   
    3. import com.meituan.hyt.test3.service.UserService;  
    4. import com.meituan.hyt.test3.service.impl.UserServiceImpl;  
    5.   
    6. import java.lang.reflect.InvocationHandler;  
    7. import java.lang.reflect.Proxy;  
    8.   
    9.   
    10. public class Main1 {  
    11.     public static void main(String[] args) {  
    12.         UserService userService = new UserServiceImpl();  
    13.         InvocationHandler invocationHandler = new MyInvocationHandler(userService);  
    14.         UserService userServiceProxy = (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),  
    15.                 userService.getClass().getInterfaces(), invocationHandler);  
    16.         System.out.println(userServiceProxy.getName(1));  
    17.         System.out.println(userServiceProxy.getAge(1));  
    18.     }  
    19. }  


    运行结果

     

    ++++++before getName++++++
    ------getName------
    ++++++after getName++++++
    Tom
    ------getAge------
    10

     

     

    public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
                                   throws IllegalArgumentException

    返回一个指定接口的代理类实例,该接口可以将方法调用指派到指定的调用处理程序。此方法相当于:

         Proxy.getProxyClass(loader, interfaces).
             getConstructor(new Class[] { InvocationHandler.class }).
             newInstance(new Object[] { handler });
     

    Proxy.newProxyInstance 抛出 IllegalArgumentException,原因与Proxy.getProxyClass 相同。

     

    参数:

    loader - 定义代理类的类加载器

    interfaces - 代理类要实现的接口列表

    h - 指派方法调用的调用处理程序

    返回:

    一个带有代理类的指定调用处理程序的代理实例,它由指定的类加载器定义,并实现指定的接口

    抛出:

    IllegalArgumentException - 如果违反传递到getProxyClass 的参数上的任何限制

    NullPointerException - 如果interfaces 数组参数或其任何元素为null,或如果调用处理程序hnull

     

     

     

    3、cglib动态代理实现

    Cglib是一个优秀的动态代理框架,它的底层使用ASM在内存中动态的生成被代理类的子类,使用CGLIB即使代理类没有实现任何接口也可以实现动态代理功能。CGLIB具有简单易用,它的运行速度要远远快于JDK的Proxy动态代理:

    CGLIB的核心类:
        net.sf.cglib.proxy.Enhancer – 主要的增强类
        net.sf.cglib.proxy.MethodInterceptor – 主要的方法拦截类,它是Callback接口的子接口,需要用户实现
        net.sf.cglib.proxy.MethodProxy – JDK的java.lang.reflect.Method类的代理类,可以方便的实现对源对象方法的调用,如使用:
        Object o = methodProxy.invokeSuper(proxy, args);//虽然第一个参数是被代理对象,也不会出现死循环的问题。

    net.sf.cglib.proxy.MethodInterceptor接口是最通用的回调(callback)类型,它经常被基于代理的AOP用来实现拦截(intercept)方法的调用。这个接口只定义了一个方法
    public Object intercept(Object object, java.lang.reflect.Method method,
    Object[] args, MethodProxy proxy) throws Throwable;

    第一个参数是代理对像,第二和第三个参数分别是拦截的方法和方法的参数。原来的方法可能通过使用java.lang.reflect.Method对象的一般反射调用,或者使用 net.sf.cglib.proxy.MethodProxy对象调用。net.sf.cglib.proxy.MethodProxy通常被首选使用,因为它更快。

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.cglib;  
    2.   
    3.   
    4. import net.sf.cglib.proxy.MethodInterceptor;  
    5. import net.sf.cglib.proxy.MethodProxy;  
    6.   
    7. import java.lang.reflect.Method;  
    8.   
    9.   
    10. public class CglibProxy implements MethodInterceptor {  
    11.     @Override  
    12.     public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {  
    13.         System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");  
    14.         System.out.println(method.getName());  
    15.         Object o1 = methodProxy.invokeSuper(o, args);  
    16.         System.out.println("++++++before " + methodProxy.getSuperName() + "++++++");  
    17.         return o1;  
    18.     }  
    19. }  

     

    [java] view plain copy  print?

    1. package com.meituan.hyt.test3.cglib;  
    2.   
    3. import com.meituan.hyt.test3.service.UserService;  
    4. import com.meituan.hyt.test3.service.impl.UserServiceImpl;  
    5. import net.sf.cglib.proxy.Enhancer;  
    6.   
    7.   
    8.   
    9. public class Main2 {  
    10.     public static void main(String[] args) {  
    11.         CglibProxy cglibProxy = new CglibProxy();  
    12.   
    13.         Enhancer enhancer = new Enhancer();  
    14.         enhancer.setSuperclass(UserServiceImpl.class);  
    15.         enhancer.setCallback(cglibProxy);  
    16.   
    17.         UserService o = (UserService)enhancer.create();  
    18.         o.getName(1);  
    19.         o.getAge(1);  
    20.     }  
    21. }  


    运行结果:

     

    ++++++before CGLIB$getName$0++++++
    getName
    ------getName------
    ++++++before CGLIB$getName$0++++++
    ++++++before CGLIB$getAge$1++++++
    getAge
    ------getAge------
    ++++++before CGLIB$getAge$1++++++

     

    JAVA反射机制

    JAVA反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意一个方法;这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
    Java反射机制主要提供了以下功能: 在运行时判断任意一个对象所属的类;在运行时构造任意一个类的对象;在运行时判断任意一个类所具有的成员变量和方法;在运行时调用任意一个对象的方法;生成动态代理。
    1. 得到某个对象的属性

    public Object getProperty(Object owner, String fieldName) throws Exception {   

         Class ownerClass = owner.getClass();   

         Field field = ownerClass.getField(fieldName);   

         Object property = field.get(owner);   

         return property;   

    }  

    public Object getProperty(Object owner, String fieldName) throws Exception {   

         Class ownerClass = owner.getClass();   

         Field field = ownerClass.getField(fieldName);   

         Object property = field.get(owner);   

         return property;   

    }  

    [java] view plain copy

    1. public Object getProperty(Object owner, String fieldName) throws Exception {  
    2.      Class ownerClass = owner.getClass();  
    3.    
    4.      Field field = ownerClass.getField(fieldName);  
    5.    
    6.      Object property = field.get(owner);  
    7.    
    8.      return property;  
    9. }  

     
    Class ownerClass = owner.getClass():得到该对象的Class。

    Field field = ownerClass.getField(fieldName):通过Class得到类声明的属性。

    Object property = field.get(owner):通过对象得到该属性的实例,如果这个属性是非公有的,这里会报IllegalAccessException。

    2. 得到某个类的静态属性

    public Object getStaticProperty(String className, String fieldName)   

                 throws Exception {   

         Class ownerClass = Class.forName(className);   

         Field field = ownerClass.getField(fieldName);   

         Object property = field.get(ownerClass);   

         return property;   

    }  

    public Object getStaticProperty(String className, String fieldName)   

                 throws Exception {   

         Class ownerClass = Class.forName(className);   

         Field field = ownerClass.getField(fieldName);   

         Object property = field.get(ownerClass);   

         return property;   

    }  

    [java] view plain copy

    1. public Object getStaticProperty(String className, String fieldName)  
    2.              throws Exception {  
    3.      Class ownerClass = Class.forName(className);  
    4.    
    5.      Field field = ownerClass.getField(fieldName);  
    6.    
    7.      Object property = field.get(ownerClass);  
    8.    
    9.      return property;  
    10. }  

     

    Class ownerClass = Class.forName(className) :首先得到这个类的Class。

    Field field = ownerClass.getField(fieldName):和上面一样,通过Class得到类声明的属性。

    Object property = field.get(ownerClass) :这里和上面有些不同,因为该属性是静态的,所以直接从类的Class里取。

    3. 执行某对象的方法

    public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {   

         Class ownerClass = owner.getClass();   

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

          Method method = ownerClass.getMethod(methodName,argsClass);   

         return method.invoke(owner, args);   

    }  

    public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {       

         Class ownerClass = owner.getClass();   

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

          Method method = ownerClass.getMethod(methodName,argsClass);   

         return method.invoke(owner, args);   

    }  

    [java] view plain copy

    1. public Object invokeMethod(Object owner, String methodName, Object[] args) throws Exception {  
    2.    
    3.      Class ownerClass = owner.getClass();  
    4.    
    5.      Class[] argsClass = new Class[args.length];  
    6.    
    7.      for (int i = 0, j = args.length; i < j; i++) {  
    8.          argsClass[i] = args[i].getClass();  
    9.      }  
    10.   
    11.       Method method = ownerClass.getMethod(methodName,argsClass);  
    12.    
    13.      return method.invoke(owner, args);  
    14. }  

     
    Class owner_class = owner.getClass() :首先还是必须得到这个对象的Class。

    5~9行:配置参数的Class数组,作为寻找Method的条件。

    Method method = ownerClass.getMethod(methodName, argsClass):通过methodName和参数的argsClass(方法中的参数类型集合)数组得到要执行的Method。

    method.invoke(owner, args):执行该Method.invoke方法的参数是执行这个方法的对象owner,和参数数组args,可以这么理解:owner对象中带有参数args的method方法。返回值是Object,也既是该方法的返回值。

    4. 执行某个类的静态方法

    public Object invokeStaticMethod(String className, String methodName,   

                 Object[] args) throws Exception {   

         Class ownerClass = Class.forName(className);   

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

        Method method = ownerClass.getMethod(methodName,argsClass);   

         return method.invoke(null, args);   

     }  

    public Object invokeStaticMethod(String className, String methodName,   

                 Object[] args) throws Exception {   

         Class ownerClass = Class.forName(className);   

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

        Method method = ownerClass.getMethod(methodName,argsClass);   

         return method.invoke(null, args);   

     }  

    [java] view plain copy

    1. public Object invokeStaticMethod(String className, String methodName,  
    2.              Object[] args) throws Exception {  
    3.      Class ownerClass = Class.forName(className);  
    4.    
    5.      Class[] argsClass = new Class[args.length];  
    6.    
    7.      for (int i = 0, j = args.length; i < j; i++) {  
    8.          argsClass[i] = args[i].getClass();  
    9.      }  
    10.    
    11.     Method method = ownerClass.getMethod(methodName,argsClass);  
    12.    
    13.      return method.invoke(null, args);  
    14.  }  

     

    基本的原理和实例3相同,不同点是最后一行,invoke的一个参数是null,因为这是静态方法,不需要借助实例运行。

    5. 新建实例

    public Object newInstance(String className, Object[] args) throws Exception {   

         Class newoneClass = Class.forName(className);   

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

         Constructor cons = newoneClass.getConstructor(argsClass);   

         return cons.newInstance(args);   

    }  

    public Object newInstance(String className, Object[] args) throws Exception {   

         Class newoneClass = Class.forName(className);    

         Class[] argsClass = new Class[args.length];   

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

             argsClass[i] = args[i].getClass();   

         }   

         Constructor cons = newoneClass.getConstructor(argsClass);   

        return cons.newInstance(args);   

    }  

    [java] view plain copy

    1. public Object newInstance(String className, Object[] args) throws Exception {  
    2.      Class newoneClass = Class.forName(className);  
    3.    
    4.      Class[] argsClass = new Class[args.length];  
    5.    
    6.      for (int i = 0, j = args.length; i < j; i++) {  
    7.          argsClass[i] = args[i].getClass();  
    8.      }  
    9.    
    10.      Constructor cons = newoneClass.getConstructor(argsClass);  
    11.    
    12.      return cons.newInstance(args);  
    13.    
    14. }  

     
    这里说的方法是执行带参数的构造函数来新建实例的方法。如果不需要参数,可以直接使用newoneClass.newInstance()来实现。

    Class newoneClass = Class.forName(className):第一步,得到要构造的实例的Class。

    第5~第9行:得到参数的Class数组。

    Constructor cons = newoneClass.getConstructor(argsClass):得到构造子。

    cons.newInstance(args):新建实例。

    6. 判断是否为某个类的实例

    public boolean isInstance(Object obj, Class cls) {   

         return cls.isInstance(obj);   

    }  

    public boolean isInstance(Object obj, Class cls) {   

     return cls.isInstance(obj);   

    }  

    [java] view plain copy

    1. public boolean isInstance(Object obj, Class cls) {  
    2.      return cls.isInstance(obj);  
    3. }  

     
    7. 得到数组中的某个元素

    public Object getByArray(Object array, int index) {   

         return Array.get(array,index);   

    }  

     

     

    java.lang.Class.getDeclaredConstructor() 方法返回一个Constructor对象,它反映此Class对象所表示的类或接口指定的构造函数。parameterTypesparameter是确定构造函数的形参类型,在Class对象声明顺序的数组。

    声明

    以下是java.lang.Class.getDeclaredConstructor()方法的声明

    public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes) throws NoSuchMethodException, SecurityException

    参数

    • parameterTypes -- 这是参数数组。

    返回值

    此方法返回具有指定参数列表构造函数的构造函数对象。

    异常

    • NoSuchMethodException -- 如果没有找到匹配的方法。

    • SecurityException --如果安全管理存在。

    例子

    下面的例子显示java.lang.Class.getDeclaredConstructor()方法的使用。

    package com.yiibai;
    
    import java.lang.reflect.*;
    
    public class ClassDemo {
    
       public static void main(String[] args) {
        
         try {
            ClassDemo cls = new ClassDemo();
            Class c = cls.getClass();
    
            // constructor with arguments as Double and Long
            Class[] cArg = new Class[2];
            cArg[0] = Double.class;
            cArg[1] = Long.class;
            Constructor ct = c.getDeclaredConstructor(cArg);
            System.out.println("Constructor = " + ct.toString());
         }
        
         catch(NoSuchMethodException e) {
            System.out.println(e.toString());
         }
            
         catch(SecurityException e) {
            System.out.println(e.toString());
         }
       }
    
       private ClassDemo() {
          System.out.println("no argument constructor");
       }
    
       public ClassDemo(Double d, Long l) {
          this.d = d;
          this.l = l;
       }
    
       Double d = new Double(3.9d);
       Long l = new Long(7687);
    }  com.yiibai;
    
    import java.lang.reflect.*;
    
    public class ClassDemo {
    
       public static void main(String[] args) {
        
         try {
            ClassDemo cls = new ClassDemo();
            Class c = cls.getClass();
    
            // constructor with arguments as Double and Long
            Class[] cArg = new Class[2];
            cArg[0] = Double.class;
            cArg[1] = Long.class;
            Constructor ct = c.getDeclaredConstructor(cArg);
            System.out.println("Constructor = " + ct.toString());
         }
        
         catch(NoSuchMethodException e) {
            System.out.println(e.toString());
         }
            
         catch(SecurityException e) {
            System.out.println(e.toString());
         }
       }
    
       private ClassDemo() {
          System.out.println("no argument constructor");
       }
    
       public ClassDemo(Double d, Long l) {
          this.d = d;
          this.l = l;
       }
    
       Double d = new Double(3.9d);
       Long l = new Long(7687);
    } 

    让我们来编译和运行上面的程序,这将产生以下结果:

    no argument constructor
    Constructor = public ClassDemo(java.lang.Double,java.lang.Long) argument constructor
    Constructor = public ClassDemo(java.lang.Double,java.lang.Long)

     

     

     

    展开全文
  • 写一个 ArrayList动态代理

    千次阅读 2018-08-27 21:05:14
    package TestProxy; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect....import java.util.ArrayList; import java.util.List; public class ProxyT...
  • 动态代理可以提供对另一个对象的访问,同时隐藏实际对象的具体事实,代理对象对客户隐藏了实际对象。动态代理可以对请求进行其他的一些处理,在不允许直接访问某些类,或需要对访问做一些特殊处理等,这时候可以考虑...
  • package ... import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.util.ArrayList; import java.util.List; /** ...
  • final List<String> list = new ArrayList<String>(); List<String> proxyInstance = (List<String>) Proxy.newProxyInstance(list.getClass().getClassLoader(), ...
  • list = new ArrayList&lt;String&gt;(); 2. 3. List&lt;String&gt; proxyInstance = 4. (List&lt;String&gt;)Proxy.newProxyInstance(list.getClass().getClassLoader(), 5. list.getCl...
  • 1、手写ArrayList package com.interview; import java.util.Arrays; public class OwnListAchieve { /** * 数组 */ private Object[] elements; /** * 数组长度 */ private int size = 0; /**
  • 动态代理

    2020-06-01 16:33:20
    JDK中为我们生成了一个类,这些类的作用就是动态生成代理对象,即动态代理 Proxy类: public static Object newProxyInstance( ClassLoader cl, //类加载器,用于加载动态生成的那个代理类 //当前类的类加载,被...
  • 深入理解动态代理02

    2019-07-13 16:47:46
    关于动态代理的内部原理请看前面的文章 深入理解动态代理。这次我们来谈谈动态代理的封装。 动态代理的封装 java通过Proxy.newProxyInstance()方法来动态获取我们需要的代理类字节文件,比如我们需要获取ArrayList的...
  • 使用动态代理的步骤: 1). 自定义 " 处理类 " ,实现: InvocationHandler( 接口 )   重写: invoke() 方法     内部添加成员属性: Object target;// 表示被代理对象;   通过构造方法赋值;   在 ...
  • 动态代理

    2012-06-06 10:51:12
    谈谈自己对动态代理的理解,举个例子, 你现在有需求,需要把字串符"abc"放到一个集合里, 我们可以这样做:  用new的方式创建一个集合  List list = new ArrayList();  然后调用add方法把字符串放进去  list....
  • @WebFilter("/*") public class SensitiveFilter implements Filter { // 1.创建一个集合装敏感词汇中的数据 ... list = new ArrayList<>(); public void doFilter(ServletRequest req, ...
  • 动态代理CglibProxy

    2014-04-09 14:02:19
    package org.apache.cxf.common.util; import java.lang.reflect.Method...import java.util.ArrayList; import java.util.List; import net.sf.cglib.proxy.Enhancer; import net.sf.cglib.proxy.MethodI...
  • 动态代理入门

    2008-11-18 09:56:19
    import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; import java.sql.Array;...import java.util.ArrayList; import java.util.L...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 126
精华内容 50
关键字:

动态代理arraylist