【Java基础】深入理解反射、反射的应用（工厂模式、代理模式）

文章目录

    • 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 反射机制提供了以下功能：

  1. 获取类的信息：可以获取类的名称、修饰符、父类、实现的接口等。
  2. 创建对象：可以通过反射实例化对象，即使不知道具体类名。
  3. 调用方法：可以通过反射获取类的方法，并调用这些方法。
  4. 访问和修改字段：可以通过反射获取和设置类的字段值。
  5. 动态代理：可以使用反射动态生成代理对象，实现 AOP（面向切面编程）等功能。
  6. 操作数组：可以通过反射创建、访问和修改数组对象。
  7. 注解处理：可以通过反射获取类、方法、字段上的注解，并进行相应的处理。

通过反射机制，可以在运行时动态地操作类和对象，解耦了编译时的依赖关系，提供了更大的灵活性和扩展性。但是需要注意，由于反射涉及到动态生成和修改类的结构，可能会影响性能，并且需要额外的权限。

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

总结就是：
上述例子反射的调用过程，可以看到获取一个类的反射对象，主要过程为：

  1. 获取类的Class实例对象
  2. 根据Class实例对象获取Constructor对象
  3. 再根据Constructor对象的newInstance方法获取到类的反射对象

获取到类的反射对象后，就可以对类进行操作了~ 例如，上述示例中对类的方法进行调用过程为：

  1. 根据Class实例对象获取到类的Method对象

  2. 再根据Method对象的invoke方法调用到具体类的方法

上面示例反向调用过程中我们是通过Class.forName("类的全局定名")这种方式来获取到类的Class实例对象，除了这种，常用的还有其他两种

2. Java反射机制中获取Class的三种方式及区别？

获取类的java.lang.Class实例对象，常见的三种方式分别为：

  1. 通过MyClass.class获取，这里的MyClass指具体类~~
  2. 通过Class.forName("类的全局定名")获取，全局定名为包名+类名
  3. 通过new MyClass().getClass()获取，这里的MyClass指具体类~
		Class<?> clz = Class.forName("Reflect.Student");		  //全类名获取
        Class<Student> 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 {
    @Override
    public void show() {
        System.out.println("生产了产品A");
    }
}
public class ProductB implements Product {
    @Override
    public void show() {
        System.out.println("生产了产品B");
    }
}

public class ProductC implements Product {
    @Override
    public 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 {

        //通过工厂生产对象A
        Product 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{
    @Override
    public 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{
    @Override
    public 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 {
    @Test
    public 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个参数，分别是：

  1. 目标对象的加载器 通过Object.getClass().getClassLoader方式获取
  2. 目标对象的实现接口类型 通过Object.getClass().getInterfaces()方式获取
  3. InnvocationHandler事件处理器 通过new实例化对象并重写invoke方法方式获取

步骤：

  1. 创建被代理类的接口，让被代理类实现接口方法
  2. 创建代理类，通过构造方法将被代理类对象注入到代理类
  3. 通过设置3个参数（1、目标对象的加载器，2、目标对象的实现接口类型，3、InnvocationHandler事件处理器（增强目标对象的方法））
  4. 编写一个返回代理对象的方法：通过Proxy代理类的newProxyInstance方法将三个参数传入，返回生成的代理对象。
  5. 在测试类中将被代理类对象通过代理类有参构造引入，然后生成代理对象，执行增强的方法

举例：
产品类接口Product_interface

/**
 * 被代理类接口
 */
public interface Product_interface {
    void sell();
}

产品类Product

/**
 * @Description TODO 被代理类
 **/
public class Product implements Product_interface{
    @Override
    public 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() {
            @Override
            public 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动态代理（没有用反射）

CGLIB（Code Generation Library）是一个基于ASM（一个Java字节码操作框架）的代码生成库，它可以在运行时动态地生成目标类的子类，从而实现对目标类的代理。

使用时需引入cglib依赖

      <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.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
无货......................

实现步骤：

  1. 引入cglib依赖
  2. 创建被代理类
  3. 创建cglib代理类并且实现MethodInterceptor 接口，重写intercept方法
  4. 通过构造方法注入被代理类对象给代理对象赋值
  5. 编写一个返回代理对象的方法：
    1、创建Enhancer对象，
    2、给Enhancer对象设置父类（被代理类）的字节码对象，
    3、给Enhancer对象设置回调函数，
    4、创建代理对象 返回代理对象
  6. 在intercept方法里面调用目标对象的方法（增强）
  7. 在测试类中将被代理类对象通过代理类有参构造引入，然后生成代理对象，执行增强的方法

参考来自：
Java–反射机制原理、几种Class获取方式及应用场景—作者：吾日三省贾斯汀

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/102663.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

leetcode316. 去除重复字母(单调栈 - java)

leetcode316. 去除重复字母(单调栈 - java)

去除重复字母 题目描述单调栈代码演示进阶优化 上期经典 题目描述 难度 - 中等 leetcode316. 去除重复字母 给你一个字符串 s &#xff0c;请你去除字符串中重复的字母&#xff0c;使得每个字母只出现一次。需保证 返回结果的字典序最小&#xff08;要求不能打乱其他字符的相对…
阅读更多...
Darshan日志分析

Darshan日志分析

标头 darshan-parser 输出的开头显示了有关作业的总体信息的摘要。还可以使用–perf、–file或–total命令行选项生成其他作业级别摘要信息。 darshan log version&#xff1a;Darshan 日志文件的内部版本号。compression method&#xff1a;压缩方法。exe&#xff1a;生成日志…
阅读更多...
【前端】 Layui点击图片实现放大、关闭效果

【前端】 Layui点击图片实现放大、关闭效果

实现效果&#xff1a;点击图片实现放大&#xff0c;点击空白处关闭效果。下图。 实现逻辑&#xff1a;二维码是使用JQ插件生成的&#xff0c;点击二维码&#xff0c;获取图片路径&#xff0c;通过Layui的弹窗显示放大后的图片。 Html <div id"qrcode" class&quo…
阅读更多...
企业数据加密软件——「天锐绿盾」

企业数据加密软件——「天锐绿盾」

「天锐绿盾」是一款企业数据加密软件&#xff0c;主要用于防止企业计算机信息被破坏、丢失和泄密。该软件采用文件过滤驱动实现透明加解密&#xff0c;对用户完全透明&#xff0c;不影响用户操作习惯。 PC访问地址&#xff1a; isite.baidu.com/site/wjz012xr/2eae091d-1b97-4…
阅读更多...
两个线程并发（乱序）执行：乱箭穿心 std::thread

两个线程并发（乱序）执行：乱箭穿心 std::thread

C自学精简教程 目录(必读) C并发编程入门 目录 在 创建2个线程并执行 创建10个线程并执行 中&#xff0c;我们已经看到了多个线程执行的顺序是没有任何保证的。 他们之间就是各自独立的同时在执行。 下面我们来看看两个线程同时往控制台打印信息&#xff0c;控制台会乱成什…
阅读更多...
YOLOv5算法改进（13）— 替换主干网络之PP-LCNet

YOLOv5算法改进（13）— 替换主干网络之PP-LCNet

前言&#xff1a;Hello大家好&#xff0c;我是小哥谈。PP-LCNet是一个由百度团队针对Intel-CPU端加速而设计的轻量高性能网络。它是一种基于MKLDNN加速策略的轻量级卷积神经网络&#xff0c;适用于多任务&#xff0c;并具有提高模型准确率的方法。与之前预测速度相近的模型相比…
阅读更多...
IDEA自定义模板

IDEA自定义模板

IDEA自定义模板 &#xff08;1&#xff09;定义sop模板 ①在Live Templates中增加模板 ②先定义一个模板的组 ③在模板组里新建模板 ④定义模板 Abbreviation:模板的缩略名称Description:模板的描述Template text:模板的代码片段应用范围。比如点击Define。选择如下&…
阅读更多...
手机怎么剪视频？分享一些剪辑工具和注意事项

手机怎么剪视频？分享一些剪辑工具和注意事项

视频剪辑是一种将多个视频片段进行剪切、合并和编辑的技术&#xff0c;它可以帮助我们制作出精彩的视频作品。如今&#xff0c;随着智能手机的普及&#xff0c;我们可以随时随地使用手机进行视频剪辑。本文将为大家介绍一些手机剪辑工具和注意事项&#xff0c;帮助大家更好地进…
阅读更多...
独家首发！openEuler 主线集成 LuaJIT RISC-V JIT 技术

独家首发！openEuler 主线集成 LuaJIT RISC-V JIT 技术

RISC-V SIG 预期随主线发布的 openEuler 23.09 创新版本会集成 LuaJIT RISC-V 支持。本次发版将提供带有完整 LuaJIT 支持的 RISC-V 环境并带有相关软件如 openResty 等软件的支持。 随着 RISC-V SIG 主线推动工作的进展&#xff0c;LuaJIT 和相关软件在 RISC-V 架构下的支持也…
阅读更多...
Spring Boot中通过maven进行多环境配置

Spring Boot中通过maven进行多环境配置

上文 java Spring Boot将不同配置拆分入不同文件管理 中 我们说到了&#xff0c;多环境的多文件区分管理 说到多环境 其实不止我们 Spring Boot有 很多的东西都有 那么 这就有一个问题 如果 spring 和 maven 都配置了环境 而且他们配的不一样 那么 会用谁的呢&#xff1f; 此…
阅读更多...
设计模式—外观模式（Facade）

设计模式—外观模式（Facade）

目录 一、什么是外观模式&#xff1f; 二、外观模式具有什么优点吗&#xff1f; 三、外观模式具有什么缺点呢&#xff1f; 四、什么时候使用外观模式&#xff1f; 五、代码展示 ①、股民炒股代码 ②、投资基金代码 ③外观模式 思维导图 一、什么是外观模式&#xff1f;…
阅读更多...
基于JavaWeb和mysql实现校园订餐前后台管理系统（源码+数据库）

基于JavaWeb和mysql实现校园订餐前后台管理系统（源码+数据库）

一、项目简介 本项目是一套基于JavaWeb和mysql实现网上书城前后端管理系统&#xff0c;主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 包含&#xff1a;项目源码、项目文档、数据库脚本等&#xff0c;该项目附带全部源码可作为毕设使用。 项目都…
阅读更多...
python conda实践 sanic框架gitee webhook实践

python conda实践 sanic框架gitee webhook实践

import subprocess import hmac import hashlib import base64 from sanic.response import text from sanic import Blueprint from git import Repo# 路由蓝图 hook_blue Blueprint(hook_blue)hook_blue.route(/hook/kaifa, methods["POST"]) async def kaifa(req…
阅读更多...
使用栈检查括号的合法性 C 实现

使用栈检查括号的合法性 C 实现

使用栈检查括号的合法性 思路讲解&#xff1a;首先从数组数组0下标开始&#xff0c;如果是左括号直接无脑压入栈&#xff0c;直到出现右括号开始判断合法与否。遇到右括号分两种情况&#xff0c;第一种是空栈的情况&#xff0c;也就是说我们第一个字符就是右括号&#xff0c;那…
阅读更多...
ShardingSphere——弹性伸缩原理

ShardingSphere——弹性伸缩原理

摘要 支持自定义分片算法&#xff0c;减少数据伸缩及迁移时的业务影响&#xff0c;提供一站式的通用弹性伸缩解决方案&#xff0c;是 Apache ShardingSphere 弹性伸缩的主要设计目标。对于使用单数据库运行的系统来说&#xff0c;如何安全简单地将数据迁移至水平分片的数据库上…
阅读更多...
shiro550漏洞分析

shiro550漏洞分析

准备工作 启动该项目 可以看到没有登录时候&#xff0c;cookie中没有rememberme字段 登录时候 当账号密码输入正确时候 登录后存在该字段 shiro特征&#xff1a; 未登陆的情况下&#xff0c;请求包的cookie中没有rememberMe字段&#xff0c;返回包set-Cookie⾥也没有del…
阅读更多...
Java-Optional类

Java-Optional类

概述 Optional是JAVA 8引入的一个类&#xff0c;用于处理可能为null的值。 利用Optional可以减少代码中if-else的判断逻辑&#xff0c;增加代码的可读性。且可以减少空指针异常的发生&#xff0c;增加代码的安全性。 常用的方法 示例 代码 public class OptionalTest {pub…
阅读更多...
Spark有两种常见的提交方式：client 模式和 cluster 模式对机器 CPU 的影响

Spark有两种常见的提交方式：client 模式和 cluster 模式对机器 CPU 的影响

Spark有两种常见的提交方式&#xff1a;client 模式和 cluster 模式。这两种方式对机器 CPU 的影响略有不同 &#xff0c;请参考以下说明 Client 模式&#xff1a; 在 Client 模式下&#xff0c;Spark Driver 运行在提交任务的客户端节点上&#xff08;即运行 spark-submit 命…
阅读更多...
一种改进多旋翼无人机动态仿真的模块化仿真环境研究（Matlab代码实现）

一种改进多旋翼无人机动态仿真的模块化仿真环境研究（Matlab代码实现）

&#x1f4a5;&#x1f4a5;&#x1f49e;&#x1f49e;欢迎来到本博客❤️❤️&#x1f4a5;&#x1f4a5; &#x1f3c6;博主优势&#xff1a;&#x1f31e;&#x1f31e;&#x1f31e;博客内容尽量做到思维缜密&#xff0c;逻辑清晰&#xff0c;为了方便读者。 ⛳️座右铭&a…
阅读更多...
Swift 如何从图片数据（Data）检测原图片类型？

Swift 如何从图片数据（Data）检测原图片类型？

功能需求 如果我们之前把图片对应的数据（Data）保持在内存或数据库中，那么怎么从 Data 对象检测出原来图片的类型呢？ 如上图所示：我们将 11 张不同类型的图片转换为 Data 数据，然后从 Data 对象正确检测出了原图片类型。 目前，我们的代码可以检测出 jpeg（jpg）, tiff,…
阅读更多...
最新文章

Copyright @ 2022~2023