定制营销的例子有哪些,广东seo点击排名软件哪家好,北京网聘信息技术有限公司,网站开发软件h开头的文章目录 1. Java反射机制是什么#xff1f;1.2 Java反射例子 2. Java反射机制中获取Class的三种方式及区别#xff1f;3. Java反射机制的应用场景有哪些#xff1f;3.1. 优化静态工厂模式#xff08;解耦#xff09;3.1.1 优化前#xff08;工厂类和产品类耦合#xff… 文章目录 1. Java反射机制是什么1.2 Java反射例子 2. Java反射机制中获取Class的三种方式及区别3. Java反射机制的应用场景有哪些3.1. 优化静态工厂模式解耦3.1.1 优化前工厂类和产品类耦合3.1.2 反射优化后工厂类和产品类解耦合3.1.3 利用反射再优化配置文件配置全类名映射 3.2 代理模式中的动态代理实现3.2.1 静态代理3.2.2 动态代理3.2.2.1 JDK动态代理反射构造代理对象3.2.2.2 cglib动态代理没有用反射 1. Java反射机制是什么
Java 反射机制是指在运行时动态地获取和操作类的信息、调用对象的方法和访问对象的属性的能力。通过反射可以在程序运行时分析和修改类的结构、行为和状态。
Java 反射机制提供了以下功能
获取类的信息可以获取类的名称、修饰符、父类、实现的接口等。创建对象可以通过反射实例化对象即使不知道具体类名。调用方法可以通过反射获取类的方法并调用这些方法。访问和修改字段可以通过反射获取和设置类的字段值。动态代理可以使用反射动态生成代理对象实现 AOP面向切面编程等功能。操作数组可以通过反射创建、访问和修改数组对象。注解处理可以通过反射获取类、方法、字段上的注解并进行相应的处理。
通过反射机制可以在运行时动态地操作类和对象解耦了编译时的依赖关系提供了更大的灵活性和扩展性。但是需要注意由于反射涉及到动态生成和修改类的结构可能会影响性能并且需要额外的权限。
1.2 Java反射例子
正射 一般情况下我们使用某个类都会知道这个类以及要用它来做什么可以直接通过new实例化创建对象然后使用这个对象对类进行操作这个就属于正射~ Student类 public class Student {private int id;public void setId(int id) {this.id id;}public int getId() {return this.id;}}Student student new Student();student.setId(1);System.out.println(正射获取ID :student.getId());//输出正射获取ID :1正射很好理解就不多说了现在来讲讲反射同样可以创建对象调用对象的方法等等正射能做的事通过反射都能做 反射 反射则是一开始并不知道要初始化的是什么类无法使用new来实例化创建对象主要是通过JDK提供的反射API来实现在运行时才知道要操作的是什么类并且可以获取到类的完整构造以及调用对应的方法这就是反射~ //1、通过 Class.forName 方法获取 Srudent类的 Class 对象Class? clz Class.forName(Reflect.Student); //2、通过 getConstructor 方法获取类的无参构造方法// Constructor? constructor clz.getConstructor();//可省略//3、通过 newInstance 方法实例化对象// Object stu constructor.newInstance();//可省略Student stu (Student) clz.newInstance();//代替2-3直接通过字节码对象Class.newInstance()实例化对象//4、通过 getMethod 方法获取类的方法信息(setId, int.class) setId为方法名 int.class为方法参数类型Method setId clz.getMethod(setId, int.class);//5、通过 invoke 方法调用该方法setId.invoke(stu,3);//也可以直接通过对象stu 调用Student类的方法Method getId clz.getMethod(getId);System.out.println(反射获取ID :getId.invoke(stu));//输出反射获取ID :3总结就是 上述例子反射的调用过程可以看到获取一个类的反射对象主要过程为
获取类的Class实例对象根据Class实例对象获取Constructor对象再根据Constructor对象的newInstance方法获取到类的反射对象
获取到类的反射对象后就可以对类进行操作了~ 例如上述示例中对类的方法进行调用过程为 根据Class实例对象获取到类的Method对象 再根据Method对象的invoke方法调用到具体类的方法
上面示例反向调用过程中我们是通过Class.forName(类的全局定名)这种方式来获取到类的Class实例对象除了这种常用的还有其他两种
2. Java反射机制中获取Class的三种方式及区别
获取类的java.lang.Class实例对象常见的三种方式分别为
通过MyClass.class获取这里的MyClass指具体类~~通过Class.forName(类的全局定名)获取全局定名为包名类名通过new MyClass().getClass()获取这里的MyClass指具体类~ Class? clz Class.forName(Reflect.Student); //全类名获取ClassStudent clz Student.class; //类.class获取Class? extends Student clz new Student().getClass();//newClass().getClass()获取区别在于
通过MyClass.class获取JVM会使用ClassLoader类加载器将类加载到内存中但并不会做任何类的初始化工作返回java.lang.Class对象通过Class.forName(“类的全局定名”)获取同样类会被JVM加载到内存中并且会进行类的静态初始化工作返回java.lang.Class对象通过newMyClass().getClass()获取这种方式使用了new进行实例化操作因此静态初始化和非静态初始化工作都会进行getClass方法属于顶级Object类中的方法任何子类对象都可以调用哪个子类调用就返回那个子类的java.lang.Class对象
具体体现可参考链接吾日三省贾斯汀-----Java–反射机制原理、几种Class获取方式及应用场景
总结
MyClass.class不会做任何类的初始化工作Class.forName会进行类的静态初始化工作new MyClass().getClass静态初始化和非静态初始化工作都会进行使用这三种方式任意一种最终在JVM加载到内存中都会是内存地址相同的(jvm类加载的双亲委派机制类只会被加载一次
3. Java反射机制的应用场景有哪些
3.1. 优化静态工厂模式解耦
3.1.1 优化前工厂类和产品类耦合
简单工厂示例
步骤1创建抽象产品类
public interface Product {void show();
}步骤2创建具体产品类
public class ProductA implements Product {Overridepublic void show() {System.out.println(生产了产品A);}
}
public class ProductB implements Product {Overridepublic void show() {System.out.println(生产了产品B);}
}public class ProductC implements Product {Overridepublic void show() {System.out.println(生产了产品C);}
}
步骤3创建简单工厂类
/*** 静态工厂*/
public class Product_factory {/*** todo 常规工厂 工厂和产品耦合)*/public static Product createProduct(String productName) throws Exception {Product product null;if (A.equals(productName)) {product new ProductA();}else if(B.equals(productName)){product new ProductB();}else if(C.equals(productName)){product new ProductC();}else{throw new Exception(没有该产品);}return product;}
}
步骤4调用简单工厂类 public static void main(String[] args) throws Exception {//通过工厂生产对象AProduct A Product_factory.createProduct(A);//调用A对象的方法A.show();Product B Product_factory.createProduct(B);B.show();Product C Product_factory.createProduct(C);C.show();}输出
A产品被生产了
B产品被生产了
B产品被生产了优化前的弊端 每增加一个接口的子类必须修改工厂类的逻辑
例如我需要加一个产品C就必须要修改工厂追加产品C的生产过程
public class ProductD implements Product{Overridepublic void show() {System.out.println(D产品被生产了);}
} 这样就违背了开闭原则在追加新产品时应该不要修改原来已有的代码而是在原来的基础上扩展
这个时候反射就可以克服这个弊端将产品和工厂解耦
3.1.2 反射优化后工厂类和产品类解耦合
优化后
优化工厂类 /*** todo 反射工厂(通过产品全类名来创建产品 工厂和产品解耦合)*/public static Product createProductReflect(String Full_product_name ) {Product product null;try {//根据产品类的全类名反射生成产品类的class字节对象Class? aClass Class.forName(Full_product_name);//通过产品类的字节码对象 创建真实对象product (Product) aClass.newInstance();}catch (Exception e){e.printStackTrace();}return product;}测试类 //全类名反射通过工厂生产产品Product A Product_factory.createProductReflect(factory.Simple_factory.ProductA);A.show();Product B Product_factory.createProductReflect(factory.Simple_factory.ProductB);B.show();Product C Product_factory.createProductReflect(factory.Simple_factory.ProductC);B.show();输出
A产品被生产了
B产品被生产了
B产品被生产了这样如果要追加产品D只需要新增产品D无需修改工厂只需要在需要D产品时通过对工厂引入产品的全类名就可以生产产品类对象 新增产品D
public class ProductD implements Product{Overridepublic void show() {System.out.println(D产品被生产了);}
}
通过对工厂引入产品的全类名生产产品类对象 Product D Product_factory.createProductReflect(factory.Simple_factory.ProductD);D.show();输出
D产品被生产了使用Java反射机制优化简单工厂模式后可以看到不论具体产品类更新多频繁都不需要再修改工厂类从而解决了普通简单工厂模式操作成本高和系统复杂性高的问题~ 3.1.3 利用反射再优化配置文件配置全类名映射 简单工厂模式的工厂类采用Java反射机制进行优化后此时的仍然存在这样一个问题子类的全局定名包名类名是写死的但是实际上开发者在写代码时是很难提前预知所有的子类的全局定名包名类名的因此需要进行二次优化~ 优化思路 通过配置文件方式统一定义类名对应全局定名包名类名将配置文件存放到资源目录下程序运行时通过ClassLoader类加载器动态获取到配置文件中定义的子类的全局定名~ 再次优化步骤2配置类名对应全局定名包名类名 创建属性配置文件Product.properties
//产品抽象类Product相关子类的全局定名包名类名定义
//key value
ProductA com.justin.java.lang.ProductA
ProductB com.justin.java.lang.ProductB
ProductC com.justin.java.lang.ProductC
再次优化步骤3修改调用工厂类
public class FactoryTest {Testpublic void test() throws IOException {ClassLoader classLoader this.getClass().getClassLoader();Properties prop new Properties();prop.load(classLoader.getResourceAsStream(Product.properties));String className ;try {className prop.getProperty(ProductA);Product productA Factory.getInstance(className);productA.show();} catch (NullPointerException e) {System.out.println(没有A这款产品无法生产~);}try {className prop.getProperty(ProductB);Product productA Factory.getInstance(className);productA.show();} catch (NullPointerException e) {System.out.println(没有B这款产品无法生产~);}try {className prop.getProperty(ProductC);Product productA Factory.getInstance(className);productA.show();} catch (NullPointerException e) {System.out.println(没有C这款产品无法生产~);}}
}
输出
生产了产品A
生产了产品B
生产了产品C相比较优化前将产品类对应的全类名放在了配置文件里面在生产产品时根据以下配置将产品类对应的全类名从配置文件里面取到然后再根据全类名反射构建产品对象 ClassLoader classLoader this.getClass().getClassLoader();Properties prop new Properties();prop.load(classLoader.getResourceAsStream(Product.properties));classLoader.getResourceAsStream(Product.properties) 是通过类加载器来获取资源文件 “Product.properties” 的输入流。getResourceAsStream() 方法是 java.lang.ClassLoader 类的一个方法它可以根据给定的路径从类路径中查找并返回对应的资源文件的输入流。
prop.load() 是 java.util.Properties 类的一个方法用于将输入流中的数据加载到属性对象中。在这行代码中prop 是一个属性对象通过调用 prop.load() 方法并将类加载器获取到的资源文件输入流作为参数实现将资源文件的内容加载到属性对象中。
综上所述这行代码的作用是使用类加载器加载名为 Product.properties 的资源文件并将其读取为属性对象。这样可以方便地获取和操作资源文件中定义的属性值。
3.2 代理模式中的动态代理实现
代理模式是什么 代理Proxy模式是一种设计模式通过代理对象来访问目标对象还可以在不修改目标对象的情况下对代理对象进行拓展增强目标对象的功能~
3.2.1 静态代理
静态代理是在编译时就已经确定代理类和被代理类的关系代理类和被代理类实现同一个接口或继承同一个父类。代理类持有对被代理对象的引用(代理对象在调用目标方法之前或之后执行一些额外的逻辑。静态代理的代码在编译时就已经确定因此代理类需要为每一个被代理类编写一个对应的代理类。这种方式的好处是简单直观容易理解和掌握但是当被代理的类较多时会产生大量的重复代码。
也就是一个被代理类对应着一个代理类但是当被代理的类较多时会产生大量的重复代码。 其实静态代理通俗的来说就是被代理类和代理类共同实现一个接口并且实现接口的方法代理类通过声明被代理类的实例化对象代理对象也就是编译时就已经确定代理类和被代理类的关系通过调用和被代理类一样的方法这就是为什么要共同实现一个接口的方法并且在代理类方法中通过代理对象调用被代理类的方法可以在被代理类的方法做出增代理类设置的增强从而达到代理或代理增强的效果 3.2.2 动态代理
动态代理是在运行时生成代理类不需要对每个被代理类都编写一个对应的代理类。它通过使用 Java 的反射机制在运行时动态地创建代理类和代理对象。代理类实现一个统一的接口或继承一个父类并持有一个 InvocationHandler 对象作为其调用处理器。在调用目标方法时代理类会将方法调用转发给 InvocationHandler 处理器并可以在调用之前或之后添加额外的逻辑,动态代理的优势在于可以更加灵活地动态创建代理对象减少了重复的代理类编写适用于代理类较多或需要动态管理代理对象的场景。
3.2.2.1 JDK动态代理反射构造代理对象
JDK 原生动态代理主要利用了JDK API的 java.lang.reflect.Proxy和java.lang.relfect.InnvocationHandler 这两个类来实现~
通过java.lang.reflect.Proxy代理类的newProxyInstance方法传递3个参数分别是
目标对象的加载器 通过Object.getClass().getClassLoader方式获取目标对象的实现接口类型 通过Object.getClass().getInterfaces()方式获取InnvocationHandler事件处理器 通过new实例化对象并重写invoke方法方式获取
步骤
创建被代理类的接口让被代理类实现接口方法创建代理类通过构造方法将被代理类对象注入到代理类通过设置3个参数1、目标对象的加载器2、目标对象的实现接口类型3、InnvocationHandler事件处理器增强目标对象的方法编写一个返回代理对象的方法通过Proxy代理类的newProxyInstance方法将三个参数传入返回生成的代理对象。在测试类中将被代理类对象通过代理类有参构造引入然后生成代理对象执行增强的方法
举例 产品类接口Product_interface
/*** 被代理类接口*/
public interface Product_interface {void sell();
}产品类Product
/*** Description TODO 被代理类**/
public class Product implements Product_interface{Overridepublic void sell() {System.out.println(生产了一台iphone 15 pro max);}
}代理类ProductProxy
/*** Description TODO 动态代理类**/
public class ProductProxy {private Object target;//被代理的对象public ProductProxy (Object target){//通过构造方法引入被代理对象this.target target;}/*** 利用JDK API获取到代理对象* return*/public Object getProxyInstance(){//目标对象的加载器ClassLoader classLoader target.getClass().getClassLoader();//反射//目标对象的实现接口类型Class?[] interfaces target.getClass().getInterfaces();//反射//InvocationHandler事件处理器实例对象InvocationHandler invocationHandler new InvocationHandler() {Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {//前置增强System.out.println(提前接到消息的黄牛正在蹲抢中.............);// 执行目标对象方法Object value method.invoke(target, args);//后置增强System.out.println(无货......................);return null;//若无返回值 就直接返回 若需要返回一个返回值 就如实返回}};//传入3个参数创建代理类的实例对象并返回return Proxy.newProxyInstance(classLoader,interfaces,invocationHandler);}
}
测试类ProductBuyTest public static void main(String[] args) {Product_interface product new Product();//创建被代理类对象ProductProxy productProxy new ProductProxy(product);//将被代理类的对象交给代理类Product_interface proxy (Product_interface) productProxy.getProxyInstance();//由代理类生成代理对象proxy.sell();//通过代理对象执行被代理类的增强方法}输出
提前接到消息的黄牛正在蹲抢中.............
富士康生产了一台iphone 15 pro max
无货......................JDK原生动态代理中获取代理示例对象过程中获取目标对象的类加载器通过target.getClass().getClassLoader获取到目标对象的类加载器target.getClass()方式获取目标对象的Class实例对象使用的就是Java反射机制来实现的~ 3.2.2.2 cglib动态代理没有用反射
CGLIBCode Generation Library是一个基于ASM一个Java字节码操作框架的代码生成库它可以在运行时动态地生成目标类的子类从而实现对目标类的代理。
使用时需引入cglib依赖 dependencygroupIdcglib/groupIdartifactIdcglib/artifactIdversion2.2.2/version/dependency产品类Product
/*** 被代理类*/
public class Product {public void sell() {System.out.println(富士康生产了一台iphone 15 pro max);}
}代理类CglibProxy
/*** Description: 代理类 用来获取代理对象*/
public class CglibProxy implements MethodInterceptor {private Object target;//被代理的对象public CglibProxy (Object target){//通过构造方法引入被代理对象this.target target;}/*** 用于构造代理对象* return*/public Object getProxyObject() {//创建Enhancer对象类似于JDK代理中的Proxy类Enhancer enhancer new Enhancer();//设置父类的字节码对象。指定父类enhancer.setSuperclass(target.getClass());//设置回调函数enhancer.setCallback(this);//创建代理对象Object proxyObject enhancer.create();return proxyObject;}/** 拦截器* 1.目标对象的方法调用* 2.行为增强* 参数 o: cglib 动态生成的代理类的实例* method:实体类所调用的都被代理的方法的引用* objects 参数列表* methodProxy:生成的代理类对方法的代理引用* */public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {//前置增强System.out.println(提前接到消息的黄牛正在蹲抢中.............);//要调用目标对象的方法Object obj method.invoke(target, objects);//后置增强System.out.println(无货......................);return null;}
}输出
提前接到消息的黄牛正在蹲抢中.............
富士康生产了一台iphone 15 pro max
无货......................实现步骤
引入cglib依赖创建被代理类创建cglib代理类并且实现MethodInterceptor 接口重写intercept方法通过构造方法注入被代理类对象给代理对象赋值编写一个返回代理对象的方法 1、创建Enhancer对象 2、给Enhancer对象设置父类被代理类的字节码对象 3、给Enhancer对象设置回调函数 4、创建代理对象 返回代理对象在intercept方法里面调用目标对象的方法增强在测试类中将被代理类对象通过代理类有参构造引入然后生成代理对象执行增强的方法
参考来自 Java–反射机制原理、几种Class获取方式及应用场景—作者吾日三省贾斯汀
