Java反射，注解，以及动态代理

Java反射，注解，以及动态代理
基础 
最近在准备实习面试，被学长问到了Java反射，注解和动态代理的内容，发现有点自己有点懵，这几天查了很多资料，就来说下自己的理解吧【如有错误，望指正】
<> <> <> <>
Java反射

首先，我们得弄清一个，什么是反射(Reflection)。简单的来说，反射就是让我们在程序运行的时候能够查看到类的信息，获取并调用类的任意方法和属性。

在Java运行时，系统会将所有的对象维护一个被称为运行是的类型标识，然后这个信息跟踪这每个对象所属的类，我们可以和根据Java专门的类访问这些信息，这个类就是
Class【实际上Class对象表示的是一个类型，它不一定是类，可能是基本数据类型，比如int】。
<> <> <> <>
Class获取方法

*
通过getClass()获取
Student stu = new Student; Class c = stu.getClass(); //如果这个类在包里面，则会将包名也打印出来 //
getSimpleName只获得类名 System.out.println(c.getName());
*
使用forName获取
同样，我们也可以使用静态方法forName获得Class对象。例如：
String className= "java.util.Random"; Class c2 = Class.forName(className);
当然，className必须为接口或者类名才能成功。

*
直接获取
Class c3 = Student.class; <> <> <> <>
由Class得到对象

*
使用Class对象的newInstance()方法来创建Class对象
Class c3 = Test.class; Object o = c3.newInstance();
其中newInstance()会根据类的默认构造器【无参构造器】
创建新的对象，如果没有默认的构造器，就会报错。假如我们的构造器里面有参数怎么办，这时候我们就需要使用java.lang.reflect.Constructor
中的newInstance()方法了。

*
使用Constructor类中的newInstance()
// getConstructor里面是构造参数的形参内容 Constructor constructor =
c3.getConstructor(String.class); Object o = constructor.newInstance("你好"); <>
<> <> <>
java反射中最重要的内容——检查类的结构

在Java的java.lang.reflect中有三个类：Field、Method、Constructor分别来描述类的域【也就是变量】，方法和构造器。

*
Field的获取以及方法
Class textClass = Test.class; // getDeclaredFields()获得这个类的全部域 //
getField()获得公有域以及其父类的公有域 Field[] fields = textClass.getDeclaredFields();
简单的来说，通过Field可以获得：

变量的权限——getModifiers()，返回int，然后通过Modifier.toString(int)获得访问权限

获得变量的类型——getType()

变量的名字——getName()

*
Method的获取以及方法
Class textClass = Test.class; //
同样可以使用getMethods()和getDeclaredMethods()返回接口和类的方法 Method[] methods =
textClass.getMethods();
通过Method可以获取：

方法的权限——getgetModifiers()

方法的返回值类型——getReturnType(),方法返回类型为Class，然后你懂得。

方法的所有参数——Parameter[] parameters = method.getParameters()；

方法的执行——invoke()。在获取一个方法后，我们可以使用invoke()来调用这个方法。

Object invoke（Object
obj,Object...args），obj为实例化后的对象【对于静态方法可以被设置null】，args为方法调用的参数

例如，
public class Test { public void say(String msg){ System.out.println(msg); }
public static void main(String[] args) throws ClassNotFoundException,
IllegalAccessException, InstantiationException, NoSuchMethodException,
InvocationTargetException{ Class c = Test.class; //
返回唯一的方法，第一个参数是方法的名字，第二个是方法参数的类型 Method method = c.getMethod("say",
String.class); Object o = c.newInstance(); method.invoke(o,"你好"); } }
*
Constructor的获取以及方法
Class textClass = Test.class; // 同样getDeclaredConstructors()和getConstructors()
Constructor[] constructors = aClass.getConstructors();
方法的的使用和Method差不多，但是它没有getReturnType()方法。

这些方法我只是简单的介绍了一下，详细信息可以参考API。
<> <> <> <>
神奇的Java注解

Java注解可以很简单的说，就是为方法或者其他数据提供描述的东西。

它的本质就是一个接口,一个继承了Annotation的接口。

*
基本java注解的类型
【元注解】：也就是在自定义一个注解时，可以注解在注解上面，有以下几个元注解——>

*
@Target：注解的作用目标，用来指明注解可以作用的目标是谁，例如类，方法或者字段属性,里面的value【为一个ElementType数组】可以指明值如下：

ElementType.TYPE：允许被修饰的注解作用在类、接口和枚举上

ElementType.FIELD：允许作用在属性字段上

ElementType.METHOD：允许作用在方法上

ElementType.PARAMETER：允许作用在方法参数上

ElementType.CONSTRUCTOR：允许作用在构造器上

ElementType.LOCAL_VARIABLE：允许作用在本地局部变量上

ElementType.ANNOTATION_TYPE：允许作用在注解上

ElementType.PACKAGE：允许作用在包上

*
@Retention：注解的生命周期，里面的value【枚举类型】可以指明值如下：

RetentionPolicy.SOURCE：当前注解编译期可见，不会写入 class 文件

RetentionPolicy.CLASS：类加载阶段丢弃，会写入 class 文件

RetentionPolicy.RUNTIME：永久保存，可以反射获取
- @Documented：注解是否应当被包含在 JavaDoc 文档中
- @Inherited：是否允许子类继承该注解
- @Repeatable：重复注解，允许这个注解在某个方法和其他数据上面重复使用

【Java内置三大注解】：除了上述元注解，Java还内置了另外三种注解——>

* @Override：子类重写父类的方法时，会使用该注解。用于检查父类是否包含该注解
* @Deprecated：当某一方法和字段不推荐使用时，使用该注解标注。
* @SuppressWarnings：压制Java的警告
*
Java注解的自定义以及实现

Java注解的自定义如下
@Target(value = {ElementType.METHOD,ElementType.TYPE}) // 注解的作用地方 @Retention
(value = RetentionPolicy.RUNTIME)// 注解的生命周期 public @interface TestAnnotation {
Stringname() default "这是个类"; int time(); }

那么我们该如果如何使用注解发挥作用呢？我们可以想想，如果我们能够获得注解的信息，那么我们是不是就可以根据注解的信息来对方法做适当的调整。这时候，当然是大名鼎鼎的反射出马了。

* java.lang.Package.getAnnotation(Class<A> annotationClass) 获得这个指令类型的注解。
使用如下：
@TestAnnotation(time = 0) public class Test { @TestAnnotation(name = "这是个方法"
,time =1) public void say(){ } public static void main(String[] args) throws
ClassNotFoundException, IllegalAccessException, InstantiationException,
NoSuchMethodException, InvocationTargetException{ // 获得类上面的注解 TestAnnotation
classAnnotation = Test.class.getAnnotation(TestAnnotation.class);
System.out.println("类的名字为："+classAnnotation.name()+"------类的时间是"
+classAnnotation.time()); Method method = Test.class.getMethod("say"); //
获得方法上面的注解 TestAnnotation methodAnnotation =
method.getAnnotation(TestAnnotation.class); System.out.println("方法的名字是："
+methodAnnotation.name()+"------方法的时间是"+methodAnnotation.time()); } } // 输出： //
类的名字为：这是个类------类的时间是0 // 方法的名字是：这是个方法------方法的时间是1
现在我们知道如何进行自定义注解的使用了，那么我们怎么能够根据注释内容的不同去改变方法的执行呢？这时候，我们我们就可以使用invoke()方法了。

举个最简单的栗子：
@TestAnnotation(name = "你好") public void say(String msg){ System.out.println(
"信息是："+msg); } public static void main(String[] args) throws
NoSuchMethodException, IllegalAccessException, InstantiationException,
InvocationTargetException{ Method method = Test.class.getMethod("say"
,String.class);// 获得方法上面的注解 TestAnnotation methodAnnotation =
method.getAnnotation(TestAnnotation.class);// 执行方法
method.invoke(Test.class.newInstance(),methodAnnotation.name()); }// 输出结果： //
信息是：你好 <> <> <> <>
代理

代理就是给某个对象提供一个代理对象，并由代理对象控制对于原对象的访问，即客户不直接操控原对象，而是通过代理对象间接地操控原对象。
代理分为：

* 静态代理：代理类是在编译时就已经实现好了，成为了一个class文件
* 动态代理：是在程序运行时动态地生成类字节码，然后加载到JVM中
有几个概念：

* 抽象角色：接口类
* 实现角色：实现类
* 代理角色：代理实现的类，最终使用的对象 <> <> <> <>
静态代理

在说动态代理之前，我们先说一下静态代理，静态代理很简单，就是工厂模式。

那么就让我们来实现一下静态代理吧

抽象角色：接口类
public interface TestService { void say(); void play(); }
实现角色：实现类
public class TestServiceImpl implements TestService { @Override public void say
() { System.out.println("说话乎"); } @Override public void play() {
System.out.println("浪的飞起"); } }
代理类
public class Test implements TestService{ private TestService testService;
public Test(TestService testService) { this.testService = testService; }
@Override public void say() { System.out.println("开始说话"); testService.say();
System.out.println("结束说话"); } @Override public void play() { System.out.println(
"开始浪"); testService.play(); System.out.println("是个狼人"); } public static void
main(String[] args) { TestServiceImpl testImpl = new TestServiceImpl(); Test
test =new Test(testImpl); test.play(); test.say(); } }
在这里面，我们可以看到，从外表看起来say()和play()方法都是由test这个代理来完成的，但实际上，真正的执行者是TestServiceImpl
来完成的，test只是在执行的时候加了一些事务逻辑。


既然有了静态代理，为什么我们还需要动态代理呢？从代码中可以看出，代理类和实现类是一一对应的，如果我们有N个实现类，都要在方法执行前加一样的逻辑，那么我们不得不创建N个代理类。这时候，我们就需要使用动态代理了。
<> <> <> <>
动态代理

本次动态代理是针对JDK动态代理进行探讨。

正如前面所说，如果我们要在很多类使用同一种逻辑时，会心态爆炸，那么我们怎么去解决这个问题呢，这时候，我们可以想一想反射。

在使用的动态代理的过程中，有两个关键的东东，一个是InvocationHandler接口，一个是Proxy类。

* InvocationHandler

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的
invoke 方法来进行调用。

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　指代我们所代理的那个真实对象,也就是实现类

method:　　指代的是我们所要调用真实对象的某个方法的Method对象

args:　　指代的是调用真实对象某个方法时接受的参数

* Proxy
Proxy这个类的作用就是用来动态创建一个代理对象的类

其中我们使用最多是newProxyInstance()去创建代理类

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

loader：一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载


interfaces：一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了

h：一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对象上

创建一个代理类，实现方法调用前或后的逻辑
public class TestHandler implements InvocationHandler{ // object为实现类的对象 private
Object object;public TestHandler(Object object) { this.object = object; }
@Override public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable { System.out.println("开始方法执行"); Object o =
method.invoke(object,args); System.out.println("方法结束"); return o; } }
实例化代理类，并
public static void main(String[] args) { // 实现类 TestService testService = new
TestServiceImpl();// 里面传入要代理的实现类对象 TestHandler testHandler = new
TestHandler(testService);/** * testService.getClass().getClassLoader()
代表我们使用这个类来加载我们代理对象 * testService.getClass().getInterfaces() 代表我们调用这些接口中的方法 *
testHandler 将代理对象与testHandler关联 */ TestService service = (TestService)
Proxy.newProxyInstance(testService.getClass().getClassLoader(),
testService.getClass().getInterfaces(),testHandler); service.play();
service.say();
反射，注解，以及动态代理就简单地介绍完了，可以这样说反射是注解以及动态代理的基础，注解的实现和动态代理都要靠反射发挥作用。

还是多读下书吧，面试实习是把杀猪刀

 

 
 

 

 
 

• « 上一篇：手把手教你搭建一个Elasticsearch集群
• » 下一篇：PySpark学习笔记（4）——MLlib和ML介绍