动态代理
调用者—>代理—>对象
动态代理就是无侵入式的给代码增加新的功能，通过接口保证后面的对象和代理需要实现同一个接口，接口中就是被代理的所有方法，代理里面就是对象要被代理的方法。
为什么需要代理
因为一个对象觉得自己身上的功能太多，就会将一部分功能代理出去，对象中什么方法想要被代理，在代理中必须有对应的方法，一般会定义一个接口，接口中的方法是想要被代理的方法
代理的详细实现过程
首先是有一个需要被代理的对象，然后这个对象中有哪个方法想要被代理，创建一个接口，接口中的方法就是这个对象想要被代理的方法，在这个对象中需要实现这个接口，然后重写这几个方法。这时候就需要一个代理类，这个代理类，这个代理类主要是用到里面的代理方法，这个方法的作用是给一个对象创建一个代理，将需要被代理的对象传入其中，然后返回的是代理的对象。在这个方法里面，需要调用一个方法，就是java.util.reflect.Proxy类里面的一个方法，由于这个方法是静态方法，所以可以直接使用类名进行调用，public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)在这个方法中，第一个参数是指定哪一个类加载器去加载生成的代理类，第二个参数是指定的接口，第三个参数是用于指定生成的代理对象要干什么，一般创建代理对象不会调用到第三个参数，后面只有通过代理对象进行方法回调的时候才会调用第三个参数，在执行这个第三个参数时，会重写invoke方法进行代理方法的实现，传入invoke方法有三个参数，第一个参数是传入代理的对象，第二个参数是传入需要运行的就是原本对象的方法，第三个参数就是传入这个方法的参数。在返回的时候，返回的是传入这个方法的invoke方法传回的值。
代码详情
- 首先是定义一个方法，里面是所有的功能，这里定义了一个明星类
public class BigStar implements Star {
private String name;
public BigStar() {
}
public BigStar(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String sing(String name) {
System.out.println(this.name + "正在唱" + name);
return "谢谢";
}
@Override
public void dance() {
System.out.println(this.name + "跳舞");
}
}
- 其次是一个需要代理的方法
/**
* 我们可以将所有想要被代理的方法定义在接口当中
*/
public interface Star {
// 唱歌
String sing(String name);
// 跳舞
void dance();
}
- 然后是一个代理类
public class ProxyUtil {
/**
* 这个方法的作用：给明星的一个对象创建一个代理
* @param bigStar 被代理的明星对象
* @return 给明星创建的代理
*/
public static Star createProxy(BigStar bigStar){
/**
* java.util.reflect.Proxy类：提供了为对象产生代理对象的方法
* public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)
* 参数一：用于指定用哪个类加载器去加载生成的代理类
* 参数二：指定接口，就是这个接口用于指定生成的代理有哪些方法
* 参数三：用于指定生成的代理对象要干什么
*/
Star star = (Star) Proxy.newProxyInstance(
ProxyUtil.class.getClassLoader(),
new Class[]{Star.class},
new InvocationHandler() {
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
/**
* 参数一：代理的对象
* 参数二：要运行的方法
* 参数三：调用方法时传递的实参
*/
if("sing".equals(method.getName())){
System.out.println("给话筒");
} else if ("dance".equals(method.getName())) {
System.out.println("准备场地");
}
return method.invoke(bigStar, args);
}
}
);
return star;
}
}
- 测试代理
public class Test {
public static void main(String[] args) {
BigStar bigStar = new BigStar("坤哥");
Star prosy = ProxyUtil.createProxy(bigStar);
String res = prosy.sing("鸡你太美");
System.out.println(res);
// ProxyUtil.createProxy(bigStar).dance();
}
}
反射
反射概念
反射就是可以在运行时分析类和执行类的能力，通过反射可以获得任意一个类的属性和方法，还可以调用这些类的属性和方法。比如下面这张图片。
反射中常用的方法
在反射中，我们可以使用三种方式调用类的字节码文件，分别是Class.forName(全类名)，类名.class，对象.getClass()；在这三种调用类的字节码的过程中，第一种一般市用在类加载过程中的，第二种经常作为参数进行调用，第三种一般是创建对象之后，然后使用对象名进行调用。当我们获取到类的字节码文件之后，就可以通过类的字节码文件去调用类中的构造方法，成员变量和成员方法以及他们相应的信息。构造方法（Constructor），使用getConstructors可以获取到所有的公共的构造方法，使用getDeclaredConstructors可以获取所有的构造方法，使用不加s的可以用来获取单个的构造方法，但是需要传入构造方法中传入的参数类型，比如Stirng就需要传入String.class，int就需要传入int.class，Declared是用来控制是否查找公共方法，当我们获取到某个对象之后，可以使用getModifiers获取修饰这个对象的权限修饰符（但是一般获取到的都是数字比如下图），使用getParameters获取这个对象中所有传入参数的类型，然后使用newInstance去构造这个对象，但是一般private修饰的方法会报错，需要使用setAccessible(true)消除掉当前方法的修饰权限。
文章来源：https://www.toymoban.com/news/detail-666028.html
反射虽然给与了我们在运行时分析类和操作类的能力，但是也增加了安全性问题，可以通过setAccessible(true)方法设置对象可被强制访问，可以破坏单例的封装性文章来源地址https://www.toymoban.com/news/detail-666028.html
所有代码
- 获取类字节码文件
/**
* Java反射
* 反射允许对类的成员变量，成员方法，构造方法的信息进行编程访问
* 可以获取到这三者的权限修饰符，名字，返回值类型。可以对获取到的属性赋值，或者获取已经有的值。
* 可以获取到成员方法返回的值，还可以获取到方法抛出的异常，方法上的注解
* 可以运行获取出来的方法
*
* 首先要获取.class字节码文件
* 获取class对象的三种方式：
* 1. Class.forName("全类名"); <源代码阶段使用>
* 2. 类名.class <类加载阶段使用>
* 3. 对象.getClass(); <运行阶段使用>
*/
public class ReflectDemo1 {
public static void main(String[] args) throws ClassNotFoundException {
Student student = new Student();
// 最常见的一种
System.out.println(Class.forName("oop.reflectdemo.reflect.Student"));
// 一般当作参数进行传递
System.out.println(Student.class);
// 当只有这个类的对象才可以使用
System.out.println(student.getClass());
}
}
- 获取类中的构造方法，属性，以及成员方法信息
/**
* Java反射
* 常见的获取构造方法，成员变量，成员方法的方法
* Java中Constructor描述构造方法，Field描述成员变量，Method描述成员方法
*/
public class ReflectDemo2 {
public static void main(String[] args) throws Exception {
// 获取字节码文件对象
Class clazz = Class.forName("oop.reflectdemo.reflect.Student");
// 获取所有公共的的构造方法
Constructor[] constructor = clazz.getConstructors();
for (Constructor constructor1 : constructor) {
System.out.println(constructor1);
}
// 获取所有的构造方法
Constructor[] declaredConstructors = clazz.getDeclaredConstructors();
for (Constructor declaredConstructor : declaredConstructors) {
System.out.println(declaredConstructor);
}
/**
* 获取单个构造方法
* 后面括号里面需输入这个构造方法的传入值类型
* 一般getConstructor只能获取到public修饰的方法，而要获取到所有权限修饰的方法必须用getDeclaredConstructor;
*
*/
clazz.getConstructor(); // 获取无参构造
clazz.getConstructor(String.class); // 获取传入参数为String类型的构造方法
Constructor declaredConstructor = clazz.getDeclaredConstructor(String.class, int.class);// 获取传入参数为int的构造方法
// 获取修饰这个对象的权限修饰符
int modifiers = declaredConstructor.getModifiers();
System.out.println(modifiers);
// 获取这个对象中所有传入参数的类型
declaredConstructor.getParameters();
declaredConstructor.setAccessible(true);
Student tom = (Student) declaredConstructor.newInstance("Tom", 21);
System.out.println(tom);
/**
* 操作成员变量
*/
// 获取public修饰的所有的成员变量
Field[] fields = clazz.getFields();
for (Field field : fields) {
System.out.println(field);
}
// 获取所有成员变量
Field[] declaredField = clazz.getDeclaredFields();
for (Field field : declaredField) {
System.out.println(field);
}
// 返回单个的成员变量对象
Field name = clazz.getDeclaredField("name");
System.out.println(name);
// 获取权限修饰符
int modifiers1 = name.getModifiers();
System.out.println(modifiers1);
// 获取名字
String name1 = name.getName();
System.out.println(name1);
// 获取类型
Class<?> type = name.getType();
System.out.println(type);
// 获取成员变量记录的值
Student s = new Student("Tom", 32);
name.setAccessible(true);
Object value = name.get(s);
System.out.println(value);
// 修改对象里面的值
name.set(s,"Jerry");
System.out.println(s.getName());
/**
* 操作成员方法
*/
// 获取所有的公共方法
Method[] methods = clazz.getMethods();
// 获取所有的方法
Method[] declaredMethods = clazz.getDeclaredMethods();
/**
* 获取方法进行调用
*/
// 获取单个方法, 传入方法名，后面跟着方法传入的参数类型
Method eat = clazz.getMethod("eat", String.class);
// 获取方法的权限修饰符
int modifiers2 = eat.getModifiers();
// 获取方法的形参
Parameter[] parameters = eat.getParameters();
// 获取方法抛出的异常
Class<?>[] exceptionTypes = eat.getExceptionTypes();
// 方法运行
Student student = new Student();
eat.setAccessible(true);
eat.invoke(student,"汉堡");
}
}
到了这里，关于Java动态代理、反射的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
