0
点赞
收藏
分享

微信扫一扫

1.2 注解反射与动态代理

左手梦圆 2022-02-13 阅读 106
java代理模式反射动态代理

目录

1.2 注解反射与动态代理

1.2.1 反射

反射的入口java.lang.Class
日常开发中的对象，分为两种，基本类型和引用类型

基本类型，（固定的 8 种）                                         
  整数：byte, short, int, long                                    
  小数：float, double                                    
  字符：char （2字节 65536个字符）                                   
  布尔值：boolean（1位）                                    
引用类型                                         
  所有的引用类型都继承自 java.lang.Object                              
  类，枚举，数组，接口都是引用类型                                    
  java.io.Serializable 接口，基本类型的包装类（比如 java.lang.Double）也是引用类型
  引用类型占4字节

1.获取class 对象 3种 方式

(1)对象**.**getClass() 方法

已经有1个对象的情况下，使用对象.getClass() 返回这个对象的class

String str = "abcd";
Class<?> clazz = str.getClass();  //返回的对象 clazz 是 String 类型。
(2)类**.**class 语法

没有创建对象的情况下，使用 类名后加上 .class

Class<?> clazz  = String.class;
Class<?> clazz1 = int.class;
String str = c.newInstance();  //获取这个类，并new出对象 
//这种方式不仅能用于引用类型，基本类型也可以。
(3)Class**.**forName()

如果是隐藏类的情况下，Class.forName(“包名.类名”) 方式返回class

//一般使用
Class<?> cl = Class.forName("com.android.auto");
Class<?> c2 = Class.forName(String.class.getName()); //完整的包名+类名
//内部类
Class<?> c3 = Class.forName("com.example.auto$Phone");

注意：
class 对象的打印：

Class<?> cl = String.class;
System.out.println(cl);
System.out.println(cl.getName());      //包名+类名
System.out.println(cl.getSimpleName());//类名

//打印：
class java.lang.String
java.lang.String
String

获取class 对象 举例：

//第一种方式获取Class对象
Student stu1 = new Student(); //这一new 产生一个Student对象，一个Class对象。
Class<?> stuClass = stu1.getClass();//获取Class对象

//第二种方式获取Class对象 
Class<?> stuClass2 = Student.class; 
System.out.println(stuClass == stuClass2);//第一种方式获取的Class对象和第二种方式获取的是同一个

//第三种方式获取Class对象
try { 
    //方式3 第一种 注意此字符串必须是真实路径，就是带包名的类路径，包名.类名
    Class<?> stuClass3 = Class.forName("com.Student");
    Class<?> stuClass3 = Class.forName(Student.class.getName()); //方式3 第二种
    System.out.println(stuClass3 == stuClass2);//判断三种方式是否获取的是同一个Class对象
} catch (ClassNotFoundException e) {
    e.printStackTrace(); 
}

2.class 对象的方法

常用方法说明
getName():String返回由该 Class对象表示的实体（类，接口，数组类，原始类型或无效）的Class，作为String。
getPackage()获取此类的包
getSuperClass():Class返回表示由 Class表示的实体的直接超类（类，接口，原语类型或空白）的 Class 。
getInterfaces():Class[]返回由该对象表示的类或接口直接实现的接口。
isArray():boolean确定此 Class对象是否表示数组类
isEnum():boolean且仅当该类在源代码中被声明为枚举时才返回true。
isInterface():boolean确定指定的 Class对象是否表示接口类型。
isPrimitive():boolean确定指定的Class对象是否表示基本类型
构造常用方法说明
Constructor [] getConstructors()获取所有public构造方法
Constructor [] getDeclaredConstructors().获取所以构造方法，不区分访问修饰符
getDeclaredConstructor(Class<?>… parameterTypes)获取指定构造方法，里面的参数类.class 如果是基本类型 例如：int.class float.class
获取Method常用方法说明
getMethods()获取所有public 方法
getDeclaredMethod(String name, Class<?>… parameterTypes))获取无限定符方法
获取Filed常用方法说明
getFields()获取所有public 变量
getDeclaredField()获取无限定符号变量

常用方法举例

Class<?> clazz1 =Student.class;
String className = clazz.getName();     //获取全类名
System.out.println("className: "+className);
if(clazz.isArray()) {                  //判断是否是数组
    System.out.println("isArray");
}else if (clazz.isInterface()) {       //判断是否是接口
    System.out.println("isInterface");
}else if (clazz.isPrimitive()){        //判断是否是基本类型
    System.out.println("Primitive");
}
if(clazz.isInstance(servant))          //判断是否是类型
{
    System.out.println("isInstance");
}

3. 类的实例化

XXX.class.newInstance() 一定要获取权限

//jdk8
String str = String.class.newInstance()
//jdk9 先获取构造器，然后通过构造器new
Constructor constructor = String.class.getDeclaredConstructor()  
constructor.setAccessible(true);
String str = constructor.newInstance();//无参数构造
constructor.setAccessible(false);

4.Constructor

1.获取所有public构造方法

public Constructor [] getConstructors()

2.获取所以构造方法，不区分访问修饰符

public Constructor [] getDeclaredConstructors()

3.获取指定构造方法

public Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)
  // Class<?>... parameterTypes 里面的参数类.class 如果是基本类型 例如：int.class float.class

例如：

Class clazz = Class.forName("fanshe.Student");
//获取所有公有构造方法
Constructor[] conArray = clazz.getConstructors();
for(Constructor c : conArray){
    System.out.println(c);
}
//所有的构造方法(包括：私有、受保护、默认、公有)
Constructor[]conArray = clazz.getDeclaredConstructors();
for(Constructor c : conArray){
System.out.println(c);
}

5.Field 成员变量的介绍

每个成员变量有类型和值。 java.lang.reflect.Field 为我们提供了获取当前对象的成员变量的类型，和重新设值的
(1)获取变量名字

Field.getName()：返回这个变量的名称

(2)获取变量的类型

Field.getType()：返回这个变量的类型
Field.getGenericType()：如果当前属性有签名属性类型就返回，否则就返回 Field.getType()

(3)获取成员变量的修饰符

Field.getModifiers() 方法获取当前成员变量的修饰符     
    成员变量可以被以下修饰符修饰：
    访问权限控制符：public, protected, private
    限制只能有一个实例的：static
    不允许修改的：final
    不会被序列化：transient
    线程共享数据的一致性：volatile

(4)获取和修改成员变量的值
获取变量：

public Field getField(String name) 公共成员字段,name 字段的名称。
public Field[] getFields()      所有公共字段数组
public Field getDeclaredField(String name) //常用可以获取当前类的publi、protecte、缺省 、privat修饰的字段
public Field[] getDeclaredFields()    
返回一个Field[]数组 公共、保护、默认（包级私有）和私有字段，但不包括继承的字段。

修改变量：

field.setAccessible(true)
field.setAccessible(false)
Field.set(Object obj, Object value)   //将value对象设置到obj里面,final 定义的变量field.set改变不了
Object Field.get(Object obj)          //从Object中获取file变量
    常见错误 
    1 ：无法转换类型导致的 java.lang.IllegalArgumentException f.set(ft, new Integer(43));
    2：反射非 public 的变量导致的 NoSuchFieldException
    3 ：修改 final类型的变量导致的 IllegalAccessException

举例:

例如：
//1.获取Class对象
Class stuClass = Class.forName("fanshe.field.Student");
//2.获取字段
System.out.println("************获取所有公有的字段********************");
Field[] fieldArray = stuClass.getFields();
 for(Field f : fieldArray){
    System.out.println(f);
}
System.out.println("************获取所有的字段(包括私有、受保护、默认的)********************");
fieldArray = stuClass.getDeclaredFields();
for(Field f : fieldArray){
   System.out.println(f);
}
注意：final 定义的变量field.set改变不了

6.Method反射

继承的方法（包括重载、重写和隐藏的）会被编译器强制执行，这些方法都无法反射。因此，反射一个类的方法时不考虑父类的方法，只考虑当前类的方法每个方法都由修饰符、返回值、参数、注解和抛出的异常组成

(1)获取成员方法的函数
Method  getMethod(String name, Class… parameterTypes)  公共成员方法，parameterType参数   Method[] getMethods()  公共方法，返回Method 对象的数组，（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）

Method  getDeclaredMethod(String name, Class… parameterTypes)  常用
返回一个 Method 对象，名字指定为name，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。 Method[] getDeclaredMethods()                                        
返回 Method 对象的一个数组，获取自己包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法
(2)调用成员方法
//1.设置setAccessible属性为true：
method.setAccessible()来改变                                          
//2.invoke调用
method.invoke(Object obj,arg...)

例：
public class Test {
    private void fun() {}
    private static void fun1() {}
}
Class<?> clazz = Test.class;
Constructor<T> con = clazz.getDeclaredConstructor();
Test t = con.newInstance();
Method method = clazz.getDeclaredMethod("fun",null);
method.setAccessible(true);
method.invoke(t,null);  
Method method = clazz.getDeclaredMethod("fun1",null);
method.invoke(null,null) 
method.setAccessible(false);
注意:当调用的方法是静态成员方法是method.invoke(null,xxx); 传入的对象可以是null
(3)无参数成员方法调用
例：
private void setButtonListener(){}                                            

//反射调用
Methodmethod = mockBtAddPhone.getClass().getDeclaredMethod("setButtonListener",null);
method.setAccessible(true);      
Object result = method.invoke(mockBtAddPhone,null);
//或者Object result = method.invoke(mockBtAddPhone);      
method.setAccessible(false);    //用完设置为false
(4)有一个参数的成员方法调用
例：
private void  set ButtonListener(int i) {}

//反射调用
Method method = mockBtAddPhone.getClass().getDeclaredMethod("setButtonListener",int.class);                                        
method.setAccessible(true);
Object result = method.invoke(mockBtAddPhone,1);//第二个参数是，正式代码接口的参数
method.setAccessible(false); // 用完设置为false
(5)有多个参数的成员方法调用
public void BTAdapterOnConnectionChangedUpdate(byte index, long devAdress, String devName, int func, byte result){}                   

//反射调用
Class[] argTypes1=new Class[5];                                       
argTypes1[0]=byte.class;                                        
argTypes1[1]=long.class;                                        
argTypes1[2]=String.class;                                        
argTypes1[3]=int.class;                                        
argTypes1[4]=byte.class;                                                                           
Method method1 = MyBTAddPhoneListenerClazz.getDeclaredMethod("BTAdapterOnConnectionChangedUpdate", argTypes1);//传递的argTypes1是代码接口的参表                  
method1.setAccessible(true);                                        
Objectresult1 = method1.invoke(obj,newObject[{(byte)0,1,null,1(byte)0});
method.setAccessible(false); // 用完设置为false
(6)关于内部类的调用

内部非静态类，默认持有外部类的this

Sceen测试类中包含BlueTooth的类，调用BlueTooth类中的onChange方法

public class Screen {
    class BlueTooth {
            public void onChange(String _str,int _num){
                System.out.println("调用内部类成功 :"+_str+" "+_num);
         }
    }
}
调用方式：
    1.先获取外部类
    2.获取内部类，通过构造函数，new出对象时，传入外部类this
    3.Method调用
注意：
    内部类的构造函数参数，默认有外部类

//获取外部类
Class<?> clazz5 = Screen.class;
Screen screen1 = (Screen) clazz5.newInstance();
//获取内部类，通过构造函数，new出对象
Class<?> clazz6 = Class.forName("com.Main.Screen$BlueTooth");
Constructor<?>[] constructors = clazz6.getDeclaredConstructors();
for (Constructor<?> con: constructors){
System.out.println(con);//com.Main.Screen$BlueTooth(com.Main.Screen)
}
constructors[0].setAccessible(true);
Object objects = constructors[0].newInstance(clazz5.newInstance());
constructors[0].setAccessible(false);
//method调用
Class<?>[] args1 = new Class[2];
args1[0]=String.class;
args1[1]=int.class;
Method method = clazz6.getDeclaredMethod("onChange",args1);
method.setAccessible(true);
method.invoke(objects,"HH",123);
method.setAccessible(false);
(7)关于成员变量的调用

调用 Screen类中的fun3()接口，fun3()接口中需要对MMvvM中的num进行判断

调用方式：
    1.类.class   获取类（Screen）。
    2.Field     获取成员变量（MvvM）
    3.field1.set  修改MvvM中num的值
    4.field.set   将MvvM变量设置到类（Screen）里面
    5.method.invo  Method调用 
--------------
public class Screen {
    private MVVM mvm;
    public Screen(){
        System.out.println("Screen() ");
        mvm = MVVM.getInstance();
    }
    public void fun3(int _num){
    if (mvm.getNum()==_num){
        System.out.println("调用条件分支成功 mvm.getNum()==_num");
    }else {
        System.out.println("调用条件分支成功 mvm.getNum()!=_num");}
    }
}
------------
public class MVVM {
    private int num;
    private static MVVM mvvm;
    public static MVVM getInstance(){
    if (mvvm==null){
        mvvm = new MVVM();
        }
    return mvvm;
    }
    public void setNum(int _num){this.num=_num;}
    public int getNum(){return this.num;}
}
//条件分支调用
try {
    //获取Screen类
    Class<?> clazz3 = Screen.class;
    Screen screen1 = (Screen) clazz3.newInstance();
    Class<?>[] args1 = new Class[1];
    args1[0]=int.class;
    Method method = clazz3.getDeclaredMethod("fun3",args1);
    Field field = clazz3.getDeclaredField("mvm");

    //获取MVVM类 将100设置到num变量
    Class<?> inner = MVVM.class;
    MVVM mvvm = (MVVM) inner.newInstance();
    Field field1 = inner.getDeclaredField("num");
    field1.setAccessible(true);
    field1.set(mvvm,100);
    field1.setAccessible(false);

    //将mvvm设置到screen1里面的screen
    field.setAccessible(true);
    field.set(screen1,mvvm);
    field.setAccessible(false);

    method.setAccessible(true);
    method.invoke(screen1,100);
    method.setAccessible(false);

} catch (NoSuchMethodException |NoSuchFieldException |IllegalAccessException |InstantiationException |InvocationTargetException e) {
    e.printStackTrace();
}
(8).invoke返回值判断
如果是string类型返回函数                                        
	Class<>  clazz=  InvokeObj.class;                                 
	Method method4 = clazz.getMethod("StringShow", String.class);         
	String result = (String) method4.invoke(clazz.newInstance(), "Thinking in java");                   Assert.assertEquals("Thinking in java",result);

如果是void函数，返回为空
    Assert.assertEquals(null,result);                                     
	public Object invoke(Objectobj,Object...args)                                               

对带有指定参数的指定对象调用由此 Method 对象表示的底层方法。个别参数被自动解包，以便与基本形参相匹配，基本参数和引用参数都随需服从方法调用转换。            
如果底层方法是静态的，那么可以忽略指定的 obj 参数。该参数可以为 null。
如果底层方法所需的形参数为 0，则所提供的 args 数组长度可以为 0 或 null。         如果底层方法是静态的，并且尚未初始化声明此方法的类，则会将其初始化。 
如果方法正常完成，则将该方法返回的值返回给调用者；如果该值为基本类型，则首先适当地将其包装在对象中。但是，如果该值的类型为一组基本类型，则数组元素不 被包装在对象中；换句话说，将返回基本类型的数组。如果底层方法返回类型为 void，则该调用返回 null

1.2.2 动态代理

Git
代理概念：给目标对象提供一个代理对象，并由代理对象控制对目标对象的引用。
目的：
（1）通过引入代理对象的方式来间接访问目标对象，防止之间访问目标对象给系统带来不必要的复杂性。
（2）通过代理对象对原有的业务逻辑增强。

(1)静态代理：一对一的关系
静态代理:例子
接口： Start
Start ->实现  RealStart
Start ->实现  ProxyStart 
ProxyStart 是代理类包含RealStart

public interface Start {
    public void bookTicket();
    public void Config();
    public void CollectMoney();
    public void sing();
}
public class RealStart implements Start{
    @Override
    public void bookTicket() {
        System.out.println("RealStart bookTicket");
    }
@Override
public void Config() {
    System.out.println("RealStart Config");
    }
@Override
public void CollectMoney() {
    System.out.println("RealStart CollectMoney");
    }
@Override
public void sing() {
    System.out.println("RealStart sing");
    }
}
public class ProxyStart implements Start {
    private Start start;
    public ProxyStart(Start _start) {
        start=_start;
}
@Override
public void bookTicket() {
    System.out.println("ProxyStart bookTicket");
}
@Override
public void Config() {
    System.out.println("ProxyStart Config");
}
@Override
public void CollectMoney() {
    System.out.println("ProxyStart CollectMoney");
}
@Override
public void sing() {
        start.sing();
    }
}
public static void main(String[] args) {
    System.out.println("-------------简单代理--------------");
    Start realStart = new RealStart();
    Start proxyStart = new ProxyStart(realStart);

    proxyStart.CollectMoney();
    proxyStart.bookTicket();
    proxyStart.sing();
}
(2)动态代理：一对多

代理类在程序运行时创建的代理方式被成为动态代理,相比于静态代理， 动态代理的优势在于可以很方便的对代理类的函数进行统一的处理，而不用修改每个代理类中的方法

在java的java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，通过这个类和这个接口可以生成JDK动态代理类和动态代理对象。

动态代理步骤：
1.真实对象接口
2.创建真实对象 实现接口
3.创建对象 实现 InvocationHandler接口
4.通过 Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{Shop.class},invocationHandler); 实现代理

举报

相关推荐

反射、注解、动态代理学习

代理模式反射

JavaSE——单元测试、反射、注解、动态代理

单元测试反射动态代理java

JVM技术 反射与动态代理

java动态代理ci代码人生

【Java笔记】反射 - 代理模式与动态代理

java开发语言面向对象蓝桥杯

单元测试：Junit框架、反射、注解、动态代理

构造器System测试方法Java后端开发

反射和动态代理

javaSystem成员变量Java后端开发

反射的应用：动态代理

javaproxy代理类ide类对象Java编程语言

反射与注解

java

注解与反射

技术

基于反射的动态代理

代理模式java
0 条评论