JAVA反射的简单理解
JAVA 反射有对象反射和方法反射
主要用户解耦框架的研发,由于没有接触过框架的开发,因此不能理解对象反射和方法反射具体产生了什么样的作用
个人理解:对象反射和方法反射,不再是以前的new操作,以Person类举例
以前获取对象: Person person = new Person();
反射方式获取对象:Person object = (Person)Class.forName('Person').newInstance();
通常获取调用方法: person.sayHello("张三");
反射方式调用方法: Method method = object.getClass().getMethod("sayHello", String.class);
method.invoke(object, "张三");
看上去我们的调用更加不便捷,但是解耦的思想是:代码中取消固定的类的依赖,采用配置等方式解耦,一旦我们需要改动,即改动配置文件或少量配置即可,
而不用一个类里面大量修改new的对象,这个时候,反射就很好用了,他的类名等都是可以通过外部配置文件加载的，或者在Spring boot中通过注解进行
装配。
例举:
Properties pro=new Properties();
//获取class目录下的配置文件
pro.load(ReflectionText.class.getClassLoader().getResourceAsStream("application.properties"));
//获取配置文件定义的数据
String className=pro.getProperty("className");
String methodName=pro.getProperty("methodName");
//加载该类进内存
Class cls = Class.forName(className);
//执行方法
cls.getMethod(methodName).invoke(cls.newInstance());
------------------------------------------------------------------------------------------------------------------------------------------
动态代理模式的产生
如果仅仅是通过反射的方式使用类,我们会发现创建起来十分繁琐,且只能直接调用反射好的方法,我理解动态代理模式其实是反射的更加便捷的封装,
其有两大特点：
1.同样继承了反射的思想,是反射的更好的封装
2.可以在调用方法之前和方法之后处理自己的逻辑,例如:基于一个特别的规则,方法就不会被调用了,而这部分逻辑不需要在类里面实现,
是通过先于类调用做到了拦截，这也产生了后面拦截器的用法。
动态代理的思想是:创建一个代理对象,该对象和实际对象是映射的,用户在使用的时候,通过代理对象调用实际对象的方法,
同时,代理对象也可以在自己内部做逻辑处理
动态代理模式有两种:
1.JDK模式
JDK代理模式要求必须提供接口才能使用
JDK动态代理实现:
（1）.创建一个实际的类（产生实际对象使用）
创建接口：
cat HelloWorld.java
package reflect.jdk;
public interface HelloWorld {
public void sayHello();
}
实现接口：
cat HelloWorldImpl.java
package reflect.jdk;
public class HelloWorldImpl implements HelloWorld{
@Override
public void sayHello() {
System.out.println("Hello World");
}
}
（2）实现动态代理
package reflect.jdk;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class JdkProxyExample implements InvocationHandler {
//真实对象
private Object target = null;
//代理对象
public Object bind(Object target){
this.target = target;
return Proxy.newProxyInstance(target.getClass().getClassLoader(),
target.getClass().getInterfaces(),
this);
}
//代理的方法逻辑
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("进入代理方法逻辑");
System.out.println("在调度真实对象之前的服务");
Object obj=method.invoke(target, args);
System.out.println("在调度真实对象之后的服务");
return obj;
}
}
（3）测试
package reflect.jdk;
public class TestJdkProxy {
public static void main(String args[]){
JdkProxyExample jdkProxyExample = new JdkProxyExample();
HelloWorld proxy = (HelloWorld) jdkProxyExample.bind(new HelloWorldImpl());
proxy.sayHello();
proxy.sayHello2();
HelloWorld a = new HelloWorldImpl();
a.sayHello();
}
}
2.GCLiB模式
GCLIB则在没有提供接口的情况下使用,需要提供一个非虚拟类
1.创建非虚拟类
cat HelloWorldImpl.java
package reflect.jdk;
public class HelloWorldImpl implements HelloWorld{
@Override
public void sayHello() {
System.out.println("Hello World");
}
}
（2）实现代理
package reflect.cglib;
import org.aopalliance.intercept.MethodInvocation;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class CglibProxyExample implements MethodInterceptor {
//生成代理对象
public Object getProxy(Class cls){
//CGLIB enhancer 增强类对象
Enhancer enhancer = new Enhancer();
//设置增强类型
enhancer.setSuperclass(cls);
//定义代理逻辑对象为当前的对象，要求当前对象实现MethodInterceptor的方法
enhancer.setCallback(this);
//生成并返回代理对象
return enhancer.create();
}
//代理逻辑方法
@Override
public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
System.out.println("调用真实对象前");
Object result = methodProxy.invokeSuper(o,objects );
System.out.println("调用真实对象后");
return result;
}
}
（3）测试
package reflect.cglib;
import reflect.jdk.HelloWorld;
import reflect.jdk.HelloWorldImpl;
public class TestCglibProxy {
public static void main(String args[]){
CglibProxyExample cglibProxyExample = new CglibProxyExample();
HelloWorldImpl helloWorld = (HelloWorldImpl) cglibProxyExample.getProxy(HelloWorldImpl.class);
helloWorld.sayHello();
}
}
两种方式的使用都是一样的流程，对象->代理对象->代理逻辑方法
不同的是，jdk的是一定要先有个对象，为了该对象能够泛化使用，才有了接口
而cglib是直接传入类，由他自己创建对象，最后仍然是走到逻辑对象和代理逻辑方法上
而代理方法其实就是之前的method.invoke 的功能
