单例+反射

赞zz

已于 2023-08-24 14:21:47 修改

阅读量198

点赞数 1

文章标签： javascript 开发语言 ecmascript

于 2023-08-24 14:20:41 首次发布

本文链接：https://blog.csdn.net/m0_69157514/article/details/132472688

版权

单例模式

一、单例模式含义：

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

单例模式是一种创建型设计模式，它确保一个类只有一个实例，并提供了一个全局访问点来访问该实例。

注意：

1、单例类只能有一个实例。

2、单例类必须自己创建自己的唯一实例。

3、单例类必须给所有其他对象提供这一实例。

二、单例模式具有以下优点：

独一无二的实例：单例模式确保一个类只能创建一个实例，这样可以避免多次实例化相同对象的浪费，节省了系统资源。
全局访问点：通过单例模式，可以在程序的任何地方访问该实例，而不需要传递实例的引用。这种全局访问点的设计可以方便地管理和调用实例的方法和属性。
懒加载：单例模式可以延迟实例的创建，在真正需要使用时才创建实例。这样可以提高程序的性能和效率，避免不必要的资源消耗。
避免竞争条件：在多线程环境下，单例模式可以避免因为多个线程同时访问创建实例的代码而导致的竞争条件问题。通过合理的线程安全处理，可以确保只有一个线程成功创建实例，并且其他线程获取到的是已经创建好的实例。
提供唯一资源访问点：某些情况下，系统中某个资源只能有一个实例进行访问，例如数据库连接池、线程池等。单例模式可以确保只有一个实例对资源进行访问，避免资源被多个实例同时占用。
可继承和扩展：单例模式可以被继承和扩展，子类可以通过扩展父类的方法来增加新的功能。同时，由于单例模式只有一个实例，子类在使用时也能够保持单例的特性。

三、单例模式的缺点：

难以扩展：由于单例模式只允许创建一个实例，因此扩展该类可能会变得困难。如果需要在系统中引入新的实例，就需要修改原有的单例类，违反了开闭原则。
对象生命周期过长：单例模式的实例通常在整个应用程序的生命周期中存在。如果某个单例对象占用大量内存或者持有大量资源，而且在使用完之后无法释放，就会导致内存泄漏和资源浪费的问题。
难以进行单元测试：由于单例模式的全局性质，测试时很难对单例对象进行模拟和替换。这使得在某些情况下，单元测试变得困难，从而影响到代码的可测试性和可维护性。
破坏封装性：为了实现单例模式，常常需要将构造函数设置为私有的，这样可以防止直接通过new关键字来创建实例。但是，这也意味着其他类无法直接继承自单例类，从而限制了类的继承关系。
可能引发并发访问的问题：在多线程环境下，如果没有合理地处理并发访问的问题，就有可能引发竞争条件和线程安全性的问题。需要额外的措施来确保单例对象在多线程环境下的正确性。

四、单例模式的实现方式有多种，下面介绍几种常见的实现方式：

① 懒汉式（线程不安全）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

这种实现方式在第一次调用getInstance()方法时才会创建实例，但是在多线程环境下存在线程安全问题。

② 懒汉式（线程安全）：

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

为了解决线程安全问题，可以在getInstance()方法上加上synchronized关键字，确保只有一个线程能够同时访问该方法。但是这种方式在多线程环境下性能较低，因为每次调用getInstance()方法都需要进行同步操作。

③ 饿汉式：

public class Singleton {
    private static Singleton instance = new Singleton();

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        return instance;
    }
}

饿汉式在类加载时就创建了实例，并通过静态变量直接返回实例。这种实现方式不存在线程安全问题，但是可能会在应用程序启动时就创建实例，导致资源的浪费。

④ 双重检查锁定：

public class Singleton {
    private volatile static Singleton instance;

    private Singleton() {
        // 私有化构造函数
    }

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁定方式结合了懒汉式和线程安全的特点。通过使用volatile关键字和双重判断，确保只有第一次创建实例时才进行同步操作，避免了每次调用getInstance()方法都进行同步操作的性能问题。

⑤ 登记式/静态内部类

public class Singleton {  
    private static class SingletonHolder {  
    private static final Singleton INSTANCE = new Singleton();  
    }  
    private Singleton (){}  
    public static final Singleton getInstance() {  
        return SingletonHolder.INSTANCE;  
    }  
}

这种方式能达到双检锁方式一样的功效，但实现更简单。对静态域使用延迟初始化，应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况，双检锁方式可在实例域需要延迟初始化时使用。

⑥ 枚举

public enum Singleton {  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}

反射模式

一、什么是反射？

反射模式是一种设计模式，它允许在运行时动态地获取和操作类的信息，包括类的属性、方法和构造函数等。通过反射，可以在编译期间无需提前知道类的具体信息，而是在运行时根据需要进行动态的类操作。

在传统的静态编程中，我们需要在编译时已经确定要使用的类，并且通过该类的名称来创建对象、调用方法等。但是，反射模式打破了这种限制，它提供了一套API，允许我们在运行时检查类的结构和实例化对象，以及动态调用类的方法。

反射模式的主要机制是通过使用`java.lang.reflect`包下的类和接口，如`Class`、`Constructor`、`Method`等。这些类和接口提供了获取和操作类的详细信息的方法，例如获取类的属性、方法、构造函数，创建对象实例，调用方法等。

使用反射模式可以实现一些动态工厂、插件化、注解处理等功能。但是需要注意的是，由于反射涉及到运行时的类型检查和动态调用，会带来一定的性能损耗。同时，反射也可能破坏代码的封装性和可读性，因此在使用反射时需要谨慎考虑其适用性和影响。

总之，反射模式是一种在运行时动态获取和操作类的信息的设计模式，它提供了一种灵活的方式来处理未知类型的类，并且可以在运行时进行动态的类操作。

二、反射模式具有以下优点：

动态性：反射模式允许在运行时动态地获取和操作类的信息，包括属性、方法、构造函数等。这使得代码具有更大的灵活性和适应性，可以根据需要动态地处理未知类型的类。
提高代码的可扩展性：通过反射，可以在不修改源代码的情况下，对现有类进行扩展和修改。可以动态地添加新的属性、方法或构造函数，而无需改变原始类的结构。
灵活的工厂模式：反射可以帮助实现灵活的工厂模式，通过读取配置文件或其他外部信息，动态地创建对象实例。这样可以避免在代码中硬编码类名，提高了代码的可维护性和可扩展性。
逆向工程：反射可以用于分析已有的类，获取其结构和元数据信息。这对于逆向工程、框架开发、代码生成等方面非常有用，可以提供更多的运行时信息和功能。
框架与插件化：反射广泛应用于框架和插件化开发中。通过反射，框架可以动态加载和管理插件，实现插件的自动注册和调用。这样可以为系统提供灵活的扩展能力。

三、反射模式的缺点：

性能损耗：反射操作通常比直接调用代码的性能要慢。因为反射需要在运行时动态地获取和操作类的信息，包括查找、解析和执行等步骤。相比于静态编译时的直接调用，这些额外的步骤会引入一定的性能开销。
安全性问题：通过反射，可以绕过访问权限限制，直接访问和修改类的私有成员。这可能导致安全漏洞和不可预料的行为，特别是当应用程序的安全性依赖于对象的封装性时。
破坏封装性：反射可以突破对类的封装，访问和修改私有成员。这可能违反了面向对象编程的原则，使代码更难以理解和维护。过度使用反射可能导致代码的可读性下降。
缺乏编译时检查：反射操作在编译时无法进行类型检查，只有在运行时才能发现错误。这增加了代码出错的风险，并且在调试和排除故障时可能更加困难。
可移植性问题：某些平台和环境可能对反射的支持程度有限。在一些受限环境下（如移动设备或某些嵌入式系统），可能不允许使用反射，或者反射的性能表现很差。

四、反射模式的实现

① 获取Class对象：通过`Class.forName()`方法可以获取指定类的Class对象，进而获取类的详细信息。

Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");

② 获取构造函数

Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);

③ 获取对象

User user = constructorsP.newInstance();

④ 获取方法

Method m2 = c3.getDeclaredMethod("add",int.class);

m2.setAccessible(true);//私有需要强制才能执行

m2.invoke(user1,5);//执行方法

⑤ 获取字段

Field field = c3.getDeclaredField("id");

field.setAccessible(true);

field.set(user, 1);

第一步：首先要有一个目标类（用来验证反射）

//在类中有私有变量和共有变量 私有构造和共有构造
public class User {
 
    public String address;
    private int id;
    private String name;
 
 
    public User() {
        System.out.println("无参构造");
    }
 
    public User(int id, String name) {
        System.out.println("全部参数构造");
        this.id = id;
        this.name = name;
    }
 
    private User(int id) {
        System.out.println("私有id的构造函数");
        this.id = id;
    }
 
    private int add(int a){
        System.out.println("私有方法");
        int i=10;
        return a+i;
    }
 
 
    public int add1(int a){
        System.out.println("共有方法");
        int i=10;
        return a+i;
    }
 
    public static int add2(int a){
        System.out.println("静态方法");
        int i=10;
        return a+i;
    }
 
    @Override
    public String toString() {
        return "User{" +
                "address='" + address + '\'' +
                ", id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

第二步：我们使用反射得到类（反射得到类有三种方式，第三种实用性强）

@org.junit.Test
    public void t1() throws ClassNotFoundException {
        System.out.println("第一种获取反射类 new 对象,对象.class");
        User user = new User();
        Class c1 = user.getClass();
        System.out.println(c1);
 
        System.out.println("第二种获取反射类 类.class");
        Class c2 = User.class;
        System.out.println(c2);
 
        System.out.println("第三种获取反射类 Class.forName(全限定名字)");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
        System.out.println(c3);
 
        System.out.println("反射类只有一个 所以都相等 但是创建的对象不相等");
        System.out.println(c1 == c2);//true
        System.out.println(c2 == c3);//true
 
 
    }

第三步：通过得到类获取构造函数创建对象、获取字段、获取方法

/**
     * 反射获取类 类通过构造得到对象
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取所有的public的方法
        System.out.println("=============getConstructors获取所有public构造=================");
        Constructor[] constructors = c3.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println("所有的public构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的public的方法
        System.out.println("=============getConstructor获取指定public构造=================");
        Constructor<User> constructorsP = c3.getConstructor(null);
        Constructor<User> constructorsP1 = c3.getConstructor(int.class, String.class);
 
        //实例化对象 无参构造不能写参数constructorsP.newInstance(1,"22");
        User user = constructorsP.newInstance();
        System.out.println(user);//输出对对象
        System.out.println(user.add1(2));//调用方法
 
        User user1 = constructorsP1.newInstance(1, "郑州");
        System.out.println(user1);
        System.out.println(user1.add1(3));
 
 
        System.out.println("公有无参构造：" + constructorsP);
        System.out.println("公有两个参数构造：" + constructorsP1);
 
        System.out.println();
 
 
        //获取所有的public,private的方法
        System.out.println("=============getDeclaredConstructors获取所有public，private构造=================");
        Constructor[] constructors1 = c3.getDeclaredConstructors();
        for (Constructor constructor : constructors1) {
            System.out.println("所有的public、peivate构造：" + constructor);
        }
        System.out.println();
 
 
        //获取指定的的private的方法
        System.out.println("=============getDeclaredConstructor获取private构造=================");
        Constructor constructors11 = c3.getDeclaredConstructor(int.class);
        System.out.println("私有一个参数构造：" + constructors11);
 
        System.out.println();
 
        System.out.println(c3);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到字段
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t3() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        //获取无参构造 并且创建对象
        Constructor<User> userConstructor = c3.getConstructor(null);
        User user = userConstructor.newInstance();
 
        System.out.println("");
        System.out.println("===========getFields获取所有的共有字段===========");
        Field[] fields = c3.getFields();
        for (Field field : fields) {
            field.set(user, "北京");
            System.out.println(field);
        }
        System.out.println("私有属性的User:" + user);
 
 
        System.out.println();
        System.out.println("===========getDeclaredFields获取所有的字段(public private)===========");
        Field[] fields1 = c3.getDeclaredFields();
        for (Field field : fields1) {
            System.out.println(field);
        }
 
        System.out.println();
        System.out.println("===========getDeclaredField获取私有和共有  getField获取共有的指定字段===========");
 
        Field field = c3.getDeclaredField("id");
        field.setAccessible(true);
        field.set(user, 1);
        field = c3.getDeclaredField("name");//获取私有
        field.setAccessible(true);//设置true 才能这设置值
        field.set(user, "麻子");
 
        field = c3.getDeclaredField("address");//获取共有
        field.set(user, "天津");
 
        System.out.println(user);
 
 
    }
 
 
    /**
     * 反射获取类 类获取到方法
     *
     * @throws ClassNotFoundException
     */
    @org.junit.Test
    public void t4() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchFieldException {
 
 
        System.out.println("第三种获取反射类");
        Class c3 = Class.forName("com.thit.DesignPartterns.创建者模式.反射.User");
 
        System.out.println("============反射构造函数，然后实例化对象============");
        User user = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
        User user1 = (User) c3.getConstructor(int.class, String.class).newInstance(1, "大大");
 
        System.out.println(user == user1);
 
        System.out.println();
        System.out.println("============getMethods反射获取public方法，包含父类object的方法===========");
        Method[] methods = c3.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
 
        System.out.println();
        System.out.println("============getMethod反射获取指定的public方法，包含父类object的方法===========");
        Method m1 = c3.getMethod("add2", int.class);
        System.out.println("方法返回值+10："+m1.invoke(user, 3));
 
 
        System.out.println();
        System.out.println("============getDeclaredMethods反射获取public和private方法 只有自己的============");
        Method[] methods1 = c3.getDeclaredMethods();
        for (Method method : methods1) {
            System.out.println(method);
        }
 
 
        System.out.println();
        System.out.println("============getDeclaredMethod反射获取public和private方法 只有自己的============");
        Method m2 = c3.getDeclaredMethod("add",int.class);
        m2.setAccessible(true);
        System.out.println("方法返回值+10："+m2.invoke(user1,5));
 
        m2=c3.getDeclaredMethod("add1",int.class);
        System.out.println("方法返回值+10："+m2.invoke(user1,11));
 
 
    }