java 反射和动态代理详解及实例代码
更新时间：2016年09月30日 14:19:18 作者：夏中伟
这篇文章主要介绍了java 反射和动态代理详解及实例代码的相关资料,需要的朋友可以参考下
一、java中的反射
1.通过反射加载类的属性和方法实例代码:
/**
* java.lang.Class 是反射的源头
* 我们创建了一个类，通过编译（javac.exe）生成对应的class文件，之后我们通过java.exe加载(jvm的类加载器加载)此class文件
* 此class文件加载到内存后，就是一个运行时类，存在缓存区，这个运行时类本事就是一个Class的实例
* 每一个运行时类只加载一次，
*/
Class<StudentExam> clazz = StudentExam.class;
StudentExam studentExam = clazz.newInstance();
System.err.println(studentExam);
System.out.println(clazz);
// Field field = clazz.getField("id"); // 通过属性调用运行时类的指定属性：属性是public类型
Field field = clazz.getDeclaredField("id"); // 属性是非public 类型
Field[] fields = clazz.getDeclaredFields(); // 获取运行时类本身(父类不行)所有声明的属性，父类使用clazz.getFields();
for (Field field2 : fields) {
int i = field2.getModifiers();
String type = Modifier.toString(i);// 获取字段属性的数据类型
System.out.println(type);
}
field.setAccessible(true);
field.set(studentExam, 11);
System.err.println(studentExam.getId());
// 通过反射调用运行时类的指定方法
Method method = clazz.getMethod("setId", Integer.class);
method.invoke(studentExam, 123); // 调用运行时类的指定方法
Method[] methods = clazz.getMethods(); // 获取所有运行时类及其父类中所有声明为public的方法
Method[] methods2 = clazz.getDeclaredMethods();// 获取运行时类本身类中声明的方法
for (Method method2 : methods) {
System.out.println(method2.getName());
}
// * 通过对象的getClass()方法获取对象的运行时类，
Exam exam = new Exam();
Class clazzExam = exam.getClass();
2.类加载器ClassLoader
/**
* Description:类加载器，加载xx.properties文件，并读取数据
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午5:32:56
* @return
*/
public void classLoader() throws IOException {
//方法一、从当前工程下加载
ClassLoader loader = this.getClass().getClassLoader();
// 路径是包下写：com\\able\\onlineExam\\resources\\config.properties
InputStream inStream = loader.getResourceAsStream("config.properties");
// 方法二、从指定的路径下加载文件
// FileInputStream fileInputStream = new FileInputStream(new File("config.properties"));
Properties properties = new Properties();
properties.load(inStream);
// properties.load(fileInputStream);
String prop = properties.getProperty("domain");
System.out.println(prop);
}
3.动态代理
静态代理:代理类和目标对象的类型都是在编译期间确定下来，不利于程序的扩展。同时每个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。
动态代理:客户通过代理类来调用其他对象的方法，并且是在程序运行时，根据需要动态创建目标类的代理对象。
代理设计模式的原理：
使用一个代理将对象包装起来，然后用该代理对象取代原始对象，任何对原始对象的调用都要通过代理，代理对象决定的那个是否以及何时将方法调用
package com.test.junit;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
Object object = myInvocationHandler.bind(realSubject);
Subject subject = (Subject) object;
subject.action();
}
}
// 动态代理的使用
interface Subject{
void action();
}
// 被代理类
class RealSubject implements Subject{
@Override
public void action() {
System.out.println("我是被代理类，记得执行我哦。。。。");
}
}
class MyInvocationHandler implements InvocationHandler{
Object object;// 实现了接口的被代理类的对象的声明
/**
* Description:①给被代理的对象实例化 ②返回一个代理类对象
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午4:13:43
* @return
*/
public Object bind(Object object){
this.object = object;
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
}
/**
* 当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object returnObject = method.invoke(object, args);
return returnObject;
}
}
4.动态代理与AOP
示例一、
package com.atguigu.spring.aop;
public interface ArithmeticCalculator {
int add(int i, int j);
int sub(int i, int j);
int mul(int i, int j);
int div(int i, int j);
}
package com.atguigu.spring.aop;
import org.springframework.stereotype.Component;
@Component("arithmeticCalculator")
public class ArithmeticCalculatorImpl implements ArithmeticCalculator {
@Override
public int add(int i, int j) {
int result = i + j;
return result;
}
@Override
public int sub(int i, int j) {
int result = i - j;
return result;
}
@Override
public int mul(int i, int j) {
int result = i * j;
return result;
}
@Override
public int div(int i, int j) {
int result = i / j;
return result;
}
}
package com.atguigu.spring.aop;
public class ArithmeticCalculatorLoggingImpl implements ArithmeticCalculator {
@Override
public int add(int i, int j) {
System.out.println("The method add begins with [" + i + "," + j + "]");
int result = i + j;
System.out.println("The method add ends with " + result);
return result;
}
@Override
public int sub(int i, int j) {
System.out.println("The method sub begins with [" + i + "," + j + "]");
int result = i - j;
System.out.println("The method sub ends with " + result);
return result;
}
@Override
public int mul(int i, int j) {
System.out.println("The method mul begins with [" + i + "," + j + "]");
int result = i * j;
System.out.println("The method mul ends with " + result);
return result;
}
@Override
public int div(int i, int j) {
System.out.println("The method div begins with [" + i + "," + j + "]");
int result = i / j;
System.out.println("The method div ends with " + result);
return result;
}
}
package com.atguigu.spring.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;
public class ArithmeticCalculatorLoggingProxy {
//要代理的对象
private ArithmeticCalculator target;
public ArithmeticCalculatorLoggingProxy(ArithmeticCalculator target) {
super();
this.target = target;
}
//返回代理对象
public ArithmeticCalculator getLoggingProxy(){
ArithmeticCalculator proxy = null;
// 代理对象有哪一个类加载器负责加载
ClassLoader loader = target.getClass().getClassLoader();
// 代理对象的类型，即其中有哪些方法
Class [] interfaces = new Class[]{ArithmeticCalculator.class};
// 当调用代理对象的其中方法时，执行下面的代码
InvocationHandler h = new InvocationHandler() {
/**
* proxy: 代理对象。 一般不使用该对象
* method: 正在被调用的方法
* args: 调用方法传入的参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
// 在方法内部不会直接调用proxy对象的某个方法，proxy.toString()会造成死循环调用invoke方法
String methodName = method.getName();
//打印日志
System.out.println("[before] The method " + methodName + " begins with " + Arrays.asList(args));
//调用目标方法
Object result = null;
try {
//前置通知
result = method.invoke(target, args);
//返回通知, 可以访问到方法的返回值
} catch (NullPointerException e) {
e.printStackTrace();
//异常通知, 可以访问到方法出现的异常
}
//后置通知. 因为方法可以能会出异常, 所以访问不到方法的返回值
//打印日志
System.out.println("[after] The method ends with " + result);
return result;
}
};
/**
* loader: 代理对象使用的类加载器。
* interfaces: 指定代理对象的类型. 即代理代理对象中可以有哪些方法.
* h: 当具体调用代理对象的方法时, 应该如何进行响应, 实际上就是调用 InvocationHandler 的 invoke 方法
*/
proxy = (ArithmeticCalculator) Proxy.newProxyInstance(loader, interfaces, h);
return proxy;
}
}
package com.atguigu.spring.aop;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Main {
public static void main(String[] args) {
// ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorImpl();
ArithmeticCalculator arithmeticCalculator = new ArithmeticCalculatorLoggingImpl();
arithmeticCalculator = new ArithmeticCalculatorLoggingProxy(arithmeticCalculator).getLoggingProxy();
int result = arithmeticCalculator.add(11, 12);
System.out.println("result:" + result);
result = arithmeticCalculator.div(21, 3);
System.out.println("result:" + result);
}
}
示例二、
package com.test.junit;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class ProxyTest {
public static void main(String[] args) {
RealSubject realSubject = new RealSubject();
MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
Object object = myInvocationHandler.bind(realSubject);
Subject subject = (Subject) object;
subject.action();
}
}
// 动态代理的使用
interface Subject{
void action();
}
// 被代理类
class RealSubject implements Subject{
@Override
public void action() {
System.out.println("我是被代理类，记得执行我哦。。。。");
}
}
class MyInvocationHandler implements InvocationHandler{
Object object;// 实现了接口的被代理类的对象的声明
/**
* Description:①给被代理的对象实例化 ②返回一个代理类对象
* @param
* @author xiazhongwei
* @data 2016年9月29日:下午4:13:43
* @return
*/
public Object bind(Object object){
this.object = object;
return Proxy.newProxyInstance(object.getClass().getClassLoader(), object.getClass().getInterfaces(), this);
}
/**
* 当通过代理类的对象发起对被重写的方法的调用时，都会转化为对如下的invok方法的调用
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
Object returnObject = method.invoke(object, args);
return returnObject;
}
}
感谢阅读此文，希望能帮助到大家，谢谢大家对本站的支持！
相关文章
通过IDEA执行gradle的任务时,在终端的输出出现中文乱码,本文主要介绍了idea Gradle 控制台中文乱码的解决,具有一定的参考价值,感兴趣的可以了解一下2024-03-03
这篇文章主要介绍了Spring Cache整合Redis实现方法详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下2020-08-08
这篇文章主要介绍了java初学者必须理解这几个问题,需要的朋友可以参考下2014-10-10
这篇文章主要介绍了Java 类的加载机制，帮助大家更好的理解和学习Java，感兴趣的朋友可以了解下2020-08-08
阿里资深技术专家:在各阶段中3年经验的java程序员应该具备哪些技术能力
这篇文章主要介绍了阿里资深技术专家:在各阶段中3年经验的java程序员应该具备哪些技术能力,本文给大家列举了一些内容，大家可以根据自己需要有方法的掌握，感兴趣的朋友跟随小编一起看看吧2020-07-07
这篇文章主要为大家详细汇总了java数组排列组合问题，具有一定的参考价值，感兴趣的小伙伴们可以参考一下2018-02-02
这篇文章主要介绍了解决引入Redisson可能会出现项目启动失败的问题,具有很好的参考价值,希望对大家有所帮助,如有错误或未考虑完全的地方,望不吝赐教2024-06-06
使用 Apache POI 在 Java 中写入 Excel
这篇文章详细介绍了如何使用ApachePOI在Java中编写Excel文件的技巧,包括创建工作簿、工作表、行和单元格,以及如何处理不同版本的Excel文件,通过详细的步骤和代码示例,读者可以快速掌握ApachePOI的基本使用方法,感兴趣的朋友一起看看吧2025-02-02
本文主要介绍了Java枚举类在生产环境中的使用方式，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧2022-02-02
在项目开发中通常会引用其他的jar，怎样把自己的项目做为一个jar包的形式发布到私服仓库中，本文就详细的介绍一下，感兴趣的可以了解一下2021-06-06
最新评论