java设计模式反射浅谈

怼烎@ 2023-10-04 13:36 19阅读 0赞

![043c778173f5d7a1ca8b92261bc4036b.png][]

23种设计模式

*  单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
 *  原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
 *  工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
 *  抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
 *  建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
 *  代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
 *  适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
 *  桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
 *  装饰（Decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。
 *  外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
 *  享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
 *  组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。
 *  模板方法（TemplateMethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
 *  策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
 *  命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
 *  职责链（Chain of Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
 *  状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
 *  观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
 *  中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
 *  迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
 *  访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
 *  备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
 *  解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

spring/springboot源码中涉及到的典型设计模式

（1）单例模式

**getSingleton()方法从缓存中获取bean**

public Object getSingleton(String beanName){
        //参数true设置标识允许早期依赖
        return getSingleton(beanName,true);
    }
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //检查缓存中是否存在实例
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            //如果为空，则锁定全局变量并进行处理。
            synchronized (this.singletonObjects) {
                //如果此bean正在加载，则不处理
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {  
                    //当某些方法需要提前初始化的时候则会调用addSingleFactory 方法将对应的ObjectFactory初始化策略存储在singletonFactories
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        //调用预先设定的getObject方法
                        singletonObject = singletonFactory.getObject();
                        //记录在缓存中，earlysingletonObjects和singletonFactories互斥
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return (singletonObject != NULL_OBJECT ? singletonObject : null);
    }

（2）代理模式：AOP底层，就是动态代理模式的实现。

（3）策略模式：Spring框架的资源访问Resource接口。根据加载的xml配置使用ResourceLoader获取Resource\[\]->遍历Resource\[\]获取InputStream 文件输入流

（4）观察者模式：ApplicationListener接口（事件监听器），当事件触发时所有的监听器都会收到消息

#### 什么是反射 ####

（1）Java反射机制的核心是在程序运行时动态加载类并获取类的详细信息，从而操作类或对象的属性和方法。本质是JVM得到class对象之后，再通过class对象进行反编译，从而获取对象的各种信息。

（2）Java属于先编译再运行的语言，程序中对象的类型在编译期就确定下来了，而当程序在运行时可能需要动态加载某些类，这些类因为之前用不到，所以没有被加载到JVM。通过反射，可以在运行时动态地创建对象并调用其属性，不需要提前在编译期知道运行的对象是谁。

**Java反射机制提供的功能**

*  在运行时判断任意一个对象所属的类
 *  在运行时构造任意一个类的对象
 *  在运行时判断任意一个类所具有的成员变量和方法
 *  在运行时调用任意一个对象的成员变量和方法
 *  生成动态代理

示例程序

public class Apple {
    
        private int price;
    
        public int getPrice() {
            return price;
        }
    
        public void setPrice(int price) {
            this.price = price;
        }
    
        public static void main(String[] args) throws Exception{
            //正常的调用
            Apple apple = new Apple();
            apple.setPrice(5);
            System.out.println("Apple Price:" + apple.getPrice());
            //使用反射调用
            Class clz = Class.forName("com.chenshuyi.api.Apple");             //通过反射得到class
            Method setPriceMethod = clz.getMethod("setPrice", int.class); //通过class得到方法
            Constructor appleConstructor = clz.getConstructor();   //通过class得到构造器
            Object appleObj = appleConstructor.newInstance();      //构造器反射实例化
            setPriceMethod.invoke(appleObj, 14);                   //执行方法
            Method getPriceMethod = clz.getMethod("getPrice");
            System.out.println("Apple Price:" + getPriceMethod.invoke(appleObj));
        }
    }

获取class的三种方式

（1）对象.getClass()方法：Student stu1 = new Student()；Class stuClass = stu1.getClass()

（2）对象.class:Class stuClass2 = Student.class;

(3) Class.forName("xxx")方式（数据库加载驱动就是这样使用的）：Class stuClass3 = Class.forName("fanshe.Student")

**创建实例：通过反射来生成对象主要有两种方法**

（1）使用Class对象的newInstance()方法来创建Class对象对应类的实例

Class<?> c = String.class;
    Object str = c.newInstance();

（2）先通过Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建对象，这种方法可以用指定的构造器构造类的实例。

//获取String的Class对象
    Class<?> str = String.class;
    //通过Class对象获取指定的Constructor构造器对象
    Constructor constructor=c.getConstructor(String.class);
    //根据构造器创建实例：
    Object obj = constructor.newInstance(“hello reflection”);

[043c778173f5d7a1ca8b92261bc4036b.png]: https://img-blog.csdnimg.cn/img_convert/043c778173f5d7a1ca8b92261bc4036b.png