【Spring】GoF 之代理模式

news2024/10/6 6:40:51

一、代理模式

在 Java 程序中的代理模式的作用：

  • 当一个对象需要受到保护的时候，可以考虑使用代理对象去完成某个行为

  • 需要给某个对象的功能进行功能增强的时候，可以考虑找一个代理进行增强

  • A 对象无法和 B 对象直接交互时，也可以使用代理模式来解决

代理模式中的三大角色：

  • 目标对象（演员）

  • 代理对象（替身演员）

  • 目标对象和代理对象的公共接口（演员与替身演员相同的行为，可以让观众不知道是替身演员）

如果使用代理模式，对于客户端程序来说，客户端是无法察觉的，客户端在使用代理对象的时候就像在使用目标对象

代理模式在代码实现上，包括两种形式：

  • 静态代理

  • 动态代理

 

二、静态代理

package org.qiu.proxy.service;

/**
 * 订单业务接口
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-16-13:09
 * @since 1.0
 */
public interface OrderService {
    /**
     * 生成订单
     */
    void generate();

    /**
     * 修改订单信息
     */
    void modify();

    /**
     * 查看订单详情
     */
    void detail();
}
package org.qiu.proxy.service;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-16-13:10
 * @since 1.0
 */
public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        // 模拟网络延迟
        try {
            Thread.sleep(1024);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成！");
    }

    @Override
    public void modify() {
        // 模拟网络延迟
        try {
            Thread.sleep(512);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改！");
    }

    @Override
    public void detail() {
        // 模拟网络延迟
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单详情......");
    }
}
public class Test {
    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImpl();
        orderService.generate();
        orderService.detail();
        orderService.modify();
    }
}

运行结果：  

项目已上线，并且运行正常，只是客户反馈系统有一些地方运行较慢，要求项目组对系统进行优化。于是项目负责人就下达了这个需求。首先需要搞清楚是哪些业务方法耗时较长，于是让我们统计每个业务方法所耗费的时长。如果是你，你该怎么做呢？

 

第一种方案

直接修改Java源代码，在每个业务方法中添加统计逻辑，如下：

package org.qiu.proxy.service;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-16-13:10
 * @since 1.0
 */
public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        // 模拟网络延迟
        try {
            Thread.sleep(1024);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成！");
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        // 模拟网络延迟
        try {
            Thread.sleep(512);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改！");
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        // 模拟网络延迟
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单详情......");
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }
}

运行效果：  

需求可以满足，但显然是违背了OCP开闭原则，这种方案不可取

第二种方案

编写一个子类继承OrderServiceImpl，在子类中重写每个方法，代码如下：

package org.qiu.proxy.service;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-16-13:24
 * @since 1.0
 */
public class OrderServiceImplSub extends OrderServiceImpl{
    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        super.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        super.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        super.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }
}
public class Test {
    public static void main(String[] args) {
        OrderService orderService = new OrderServiceImplSub();
        orderService.generate();
        orderService.detail();
        orderService.modify();
    }
}

运行效果：  

这种方式可以解决，但是存在两个问题：

  • 第一个问题：假设系统中有100个这样的业务类，需要提供100个子类，并且之前写好的创建Service对象的代码，都要修改为创建子类对象

  • 第二个问题：由于采用了继承的方式，导致代码之间的耦合度较高。

这种方案也不可取

第三种方案

使用代理模式（这里采用静态代理）

可以为 OrderService 接口提供一个代理类

package org.qiu.proxy.service;

/**
 * 代理对象
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-16-13:32
 * @since 1.0
 */
public class OrderServiceProxy implements OrderService {

    // 目标对象
    // 这里要使用“公共接口”类型，因为公共接口耦合度低
    private OrderService orderService;

    // 通过构造方法将目标对象传递给代理对象
    public OrderServiceProxy(OrderService orderService){
        this.orderService = orderService;
    }

    @Override
    public void generate() {
        long begin = System.currentTimeMillis();
        // 执行目标对象的目标方法
        orderService.generate();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void modify() {
        long begin = System.currentTimeMillis();
        orderService.modify();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }

    @Override
    public void detail() {
        long begin = System.currentTimeMillis();
        orderService.detail();
        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));
    }
}

这种方式的优点：

符合OCP开闭原则，同时采用的是关联关系，所以程序的耦合度较低。所以这种方案是被推荐的 

package org.qiu.proxy.client;

import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.OrderServiceImplSub;
import org.qiu.proxy.service.OrderServiceProxy;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.client
 * @date 2022-11-16-13:13
 * @since 1.0
 */
public class Test {
    public static void main(String[] args) {
        // 创建目标对象
        OrderService target = new OrderServiceImpl();
        // 创建代理对象
        OrderService proxy = new OrderServiceProxy(target);
        // 调用代理对象的代理方法
        proxy.generate();
        proxy.modify();
        proxy.detail();
    }
}

运行效果：  

以上就是代理模式中的静态代理，其中：

OrderService 接口是代理类和目标类的共同接口

OrderServiceImpl 是目标类

OrderServiceProxy 是代理类

思考一下：如果系统中业务接口很多，一个接口对应一个代理类，显然也是不合理的，会导致类爆炸。怎么解决这个问题？动态代理可以解决。因为在动态代理中可以在内存中动态的为我们生成代理类的字节码。代理类不需要我们写了。类爆炸解决了，而且代码只需要写一次，代码也会得到复用

 

三、动态代理 

在程序运行阶段，在内存中动态生成代理类，被称为动态代理，目的是为了减少代理类的数量，解决代码复用的问题

在内存当中动态生成类的技术常见的包括：

  • JDK 动态代理技术：只能代理接口

  • CGLIB 动态代理技术：CGLIB(Code Generation Library)是一个开源项目。是一个强大的，高性能，高质量的Code生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。它既可以代理接口，又可以代理类，底层是通过继承的方式实现的。性能比 JDK 动态代理要好（底层有一个小而快的字节码处理框架ASM）

  • Javassist 动态代理技术：Javassist 是一个开源的分析、编辑和创建 Java 字节码的类库。是由东京工业大学的数学和计算机科学系的 Shigeru Chiba （千叶 滋）所创建的。它已加入了开放源代码 JBoss 应用服务器项目，通过使用 Javassist 对字节码操作为 JBoss 实现动态"AOP"框架。

JDK 动态代理 

package org.qiu.proxy.service;

/**
 * 订单业务接口
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-08:23
 * @since 1.0
 */
public interface OrderService {
    /**
     * 生成订单
     */
    void generate();

    /**
     * 修改订单信息
     */
    void modify();

    /**
     * 查看订单详情
     */
    void detail();
}
package org.qiu.proxy.service;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-08:23
 * @since 1.0
 */
public class OrderServiceImpl implements OrderService{
    @Override
    public void generate() {
        // 模拟网络延迟
        try {
            Thread.sleep(1024);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已生成！");
    }

    @Override
    public void modify() {
        // 模拟网络延迟
        try {
            Thread.sleep(512);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单已修改！");
    }

    @Override
    public void detail() {
        // 模拟网络延迟
        try {
            Thread.sleep(800);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("订单详情......");
    }
}

使用静态代理的时候，除了以上一个接口和一个实现类之外，还需要写一个代理类 UserServiceProxy！在动态代理中UserServiceProxy 代理类是可以动态生成的，这个类不需要写。我们直接写客户端程序即可：  

package org.qiu.proxy.client;

import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.TimeInvocatioinHandler;
import org.qiu.proxy.util.ProxyUtil;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.client
 * @date 2022-11-20-08:22
 * @since 1.0
 */
public class Test {
    public static void main(String[] args) {
        OrderService target = new OrderServiceImpl();
        /**
         * 参数解析：
         * 参数一：Classloader loader 类加载器
         *      JDK要求，目标类的类加载器必须和代理类的类加载器使用同一个
         * 参数二：Class<?>[] interfaces 代理类要实现的接口
         *      代理类和目标类要实现同一个接口或同一些接口
         * 参数三：InvocationHandler h 调用处理器对象（是一个接口）
         *      在这里实现功能的增强（这里采用内部实现类，也可以将其独立出来）
         */
        OrderService orderServiceProxy = (OrderService) 
            Proxy.newProxyInstance(target.getClass().getClassLoader(), 
                                   target.getClass().getInterfaces(), 
                                   new TimeInvocatioinHandler(target)
            );
        orderServiceProxy.detail();
        orderServiceProxy.modify();
        orderServiceProxy.generate();
    }
}
package org.qiu.proxy.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-09:01
 * @since 1.0
 */
public class TimeInvocatioinHandler implements InvocationHandler {

    private Object target;

    public TimeInvocatioinHandler(Object target) {
        this.target = target;
    }

    /**
     * invoke 什么时候被调用？
     *  当代理对象调用代理方法的时候，注册在 InvocationHandler 调用处理器当中的 invoke 方法被调用
     *
     * @param proxy     代理对象的引用
     * @param method    目标对象上的目标方法
     * @param args      目标方法上的实际参数
     * @return          若代理对象代用代理方法之后需要返回结果的话，invoke方法必须将目标对象目标方法执行结果继续返回
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long begin = System.currentTimeMillis();

        // 调用目标对象上的目标方法
        Object resultValue = method.invoke(target, args);

        long end = System.currentTimeMillis();
        System.out.println("耗时（毫秒）：" + (end - begin));

        return null;
    }
}

上面调用 JDK 自带的方法比较繁琐，这里可以封装一个工具类，方便使用：  

package org.qiu.proxy.util;

import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.TimeInvocatioinHandler;

import java.lang.reflect.Proxy;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.util
 * @date 2022-11-20-09:12
 * @since 1.0
 */
public class ProxyUtil {

    /**
     * 获取代理对象（JDK动态代理）
     * @param target
     * @return
     */
    public static Object newProxyInstance(Object target){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimeInvocatioinHandler(target));
    }

}
package org.qiu.proxy.client;

import org.qiu.proxy.service.OrderService;
import org.qiu.proxy.service.OrderServiceImpl;
import org.qiu.proxy.service.TimeInvocatioinHandler;
import org.qiu.proxy.util.ProxyUtil;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.client
 * @date 2022-11-20-08:22
 * @since 1.0
 */
public class Test {
    public static void main(String[] args) {
        OrderService target = new OrderServiceImpl();
        /**
         * 参数解析：
         * 参数一：Classloader loader 类加载器
         *      JDK要求，目标类的类加载器必须和代理类的类加载器使用同一个
         * 参数二：Class<?>[] interfaces 代理类要实现的接口
         *      代理类和目标类要实现同一个接口或同一些接口
         * 参数三：InvocationHandler h 调用处理器对象（是一个接口）
         *      在这里实现功能的增强（这里采用内部实现类，也可以将其独立出来）
         */
        /*
        OrderService orderServiceProxy = (OrderService) Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new TimeInvocatioinHandler(target));*/
        // 工具类封装
        OrderService orderServiceProxy = (OrderService) ProxyUtil.newProxyInstance(target);
        orderServiceProxy.detail();
        orderServiceProxy.modify();
        orderServiceProxy.generate();
    }
}

 

CGLIB 动态代理

CGLIB 既可以代理接口，又可以代理类。底层采用继承的方式实现。所以被代理的目标类不能使用 final 修饰。

使用CGLIB，需要引入它的依赖：

<dependency>
  <groupId>cglib</groupId>
  <artifactId>cglib</artifactId>
  <version>3.3.0</version>
</dependency>

准备一个没有实现接口的类，如下：  

package org.qiu.proxy.service;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-09:22
 * @since 1.0
 */
public class UserService {
    public void login(){
        System.out.println("用户正在登录系统....");
    }

    public void logout(){
        System.out.println("用户正在退出系统....");
    }
}

使用 CGLIB 在内存中为 UserService 类生成代理类，并创建对象：  

package org.qiu.proxy.client;

import net.sf.cglib.proxy.Enhancer;
import org.qiu.proxy.service.TimerMethodInterceptor;
import org.qiu.proxy.service.UserService;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.client
 * @date 2022-11-20-09:23
 * @since 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建字节码增强器
        Enhancer enhancer = new Enhancer();
        // 告诉cglib要继承哪个类
        enhancer.setSuperclass(UserService.class);
        // 设置回调接口
        enhancer.setCallback(方法拦截器对象);
        // 生成源码，编译class，加载到JVM，并创建代理对象
        UserService userServiceProxy = (UserService)enhancer.create();

        userServiceProxy.login();
        userServiceProxy.logout();
    }
}

和JDK动态代理原理差不多，在CGLIB中需要提供的不是InvocationHandler，而是：net.sf.cglib.proxy.MethodInterceptor

编写MethodInterceptor接口实现类：

package org.qiu.proxy.service;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-09:24
 * @since 1.0
 */
public class TimerMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        return null;
    }
}

 

MethodInterceptor接口中有一个方法intercept()，该方法有4个参数：

第一个参数：目标对象

第二个参数：目标方法

第三个参数：目标方法调用时的实参

第四个参数：代理方法

在MethodInterceptor的intercept()方法中调用目标以及添加增强：

package org.qiu.proxy.service;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.service
 * @date 2022-11-20-09:24
 * @since 1.0
 */
public class TimerMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object target, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        // 前增强
        long begin = System.currentTimeMillis();
        // 调用目标
        Object retValue = methodProxy.invokeSuper(target, objects);
        // 后增强
        long end = System.currentTimeMillis();
        System.out.println("耗时" + (end - begin) + "毫秒");
        // 一定要返回
        return retValue;
    }
}

回调已经写完了，可以修改客户端程序了：  

package org.qiu.proxy.client;

import net.sf.cglib.proxy.Enhancer;
import org.qiu.proxy.service.TimerMethodInterceptor;
import org.qiu.proxy.service.UserService;

/**
 * @author 秋玄
 * @version 1.0
 * @email qiu_2022@aliyun.com
 * @project Spring
 * @package org.qiu.proxy.client
 * @date 2022-11-20-09:23
 * @since 1.0
 */
public class Client {
    public static void main(String[] args) {
        // 创建字节码增强器
        Enhancer enhancer = new Enhancer();
        // 告诉cglib要继承哪个类
        enhancer.setSuperclass(UserService.class);
        // 设置回调接口
        enhancer.setCallback(new TimerMethodInterceptor());
        // 生成源码，编译class，加载到JVM，并创建代理对象
        UserService userServiceProxy = (UserService)enhancer.create();

        userServiceProxy.login();
        userServiceProxy.logout();
    }
}

对于高版本的JDK，如果使用CGLIB，需要在启动项中添加两个启动参数：  

  • --add-opens java.base/java.lang=ALL-UNNAMED

  • --add-opens java.base/sun.net.util=ALL-UNNAMED

 

一  叶  知  秋，奥  妙  玄  心

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MySQL5.7压缩包安装图文教程

MySQL5.7压缩包安装图文教程

一、下载 https://dev.mysql.com/downloads/mysql/ 选择5.7版本 二、解压 下载完成后解压&#xff0c;解压后如下&#xff08;zip是免安装的&#xff0c;解压后配置成功即可使用&#xff09; 注意&#xff1a;只有5.6以前的版本才有在线安装&#xff08;install msi&#xf…
阅读更多...
徐孝雅：一位清华毕业温州人的科技报国之路

徐孝雅：一位清华毕业温州人的科技报国之路

图 徐孝雅 偶然的一次聚会,朋友讲述一位科技企业家的传奇故事,出于记者的敏感,我对这位企业家产生了好奇。 2024年4月,我们如约见到这位企业家,他叫徐孝雅。他给我的印象极其深刻,中等身材,儒雅大方,气度不凡,眼神展露坚定和自信,浑身散发神采和活力。寒暄之后,似乎一见如故…
阅读更多...
armbian 安装libreoffice 转换word为PDF

armbian 安装libreoffice 转换word为PDF

安装libreoffice sudo apt-get install libreoffice安装JVM sudo apt-get install default-jre #验证 java -version尝试转换&#xff1a; libreoffice --convert-to pdf /root/printFiles/f.docx发现问题乱码 从Windows 拷贝字体到debian上&#xff0c;windows字体路径是&a…
阅读更多...
第十二讲：指针（4）

第十二讲：指针（4）

第十二讲&#xff1a;指针&#xff08;4&#xff09; 1.回调函数1.1什么是回调函数1.2深入理解并使用回调函数1.2.1简单写法1.2.2优化 2.qsort函数详解2.1函数简单介绍2.3qsort函数使用举例2.3.1qsort函数排序整形数据2.3.2qsort函数排序结构数据 3.qsort函数的模拟实现3.1冒泡…
阅读更多...
网络实验新境界，PNETLab模拟器部署指南

网络实验新境界，PNETLab模拟器部署指南

在网络工程领域&#xff0c;拥有一个可靠的网络实验平台至关重要。PNETLab模拟器是一款功能强大的网络仿真工具&#xff0c;它支持包括华为、华三、锐捷、思科在内的多种设备&#xff0c;并且以开源免费的形式提供&#xff0c;这使得它在业界备受青睐。 软件介绍 PNETLab&am…
阅读更多...
ThingsBoard版本控制配合Gitee实现版本控制

ThingsBoard版本控制配合Gitee实现版本控制

1、概述 2、架构 3、导出设置 4、仓库 5、同步策略 6、扩展 7、案例 7.1、首先需要在Giitee上创建对应同步到仓库地址 ​7.2、giit仓库只能在租户层面进行配置 7.3、 配置完成后&#xff1a;检查访问权限。显示已成功验证仓库访问&#xff01;表示配置成功 7.4、添加设…
阅读更多...
【代码随想录】【动态规划】背包问题 - 完全背包

【代码随想录】【动态规划】背包问题 - 完全背包

完全背包 模板&#xff1a;完全背包问题 问题描述 完全背包问题与01背包问题唯一的区别在于&#xff1a; 在01背包中&#xff1a;每个物品只有一个&#xff0c;要么放入背包&#xff0c;要么不放入背包在完全背包中&#xff1a;每个物品有无限多个&#xff0c;可以不放入背…
阅读更多...
使用Eigen将经纬度、高程、偏北角转成变换矩阵

使用Eigen将经纬度、高程、偏北角转成变换矩阵

目录 1、前言 2、示例 3、代码解析 4、垂直于给定点的切平面变换 5、代码解析 1、前言 在地球表面进行刚体变换时候&#xff0c;要将具有经纬度、高程和偏北角的坐标信息转换为变换矩阵表达&#xff0c;首先需要了解坐标系之间的转换关系。 通常&#xff0c;我们会将经纬…
阅读更多...
C++进阶：哈希（1）

C++进阶：哈希（1）

目录 1. 简介unordered_set与unordered_map2. 哈希表&#xff08;散列&#xff09;2.1 哈希表的引入2.2 闭散列的除留余数法2.2.1 前置知识补充与描述2.2.2 闭散列哈希表实现 2.3 开散列的哈希桶2.3.1 结构描述2.3.2 开散列哈希桶实现2.3.3 哈希桶的迭代器与key值处理仿函数 3.…
阅读更多...
第五届电子通讯与人工智能学术会议（ICECAI 2024, 5/31-6/2）

第五届电子通讯与人工智能学术会议（ICECAI 2024, 5/31-6/2）

目录 1. 会议官方2. 会议新闻中华人民共和国教育部新闻 3. 出版历史4. 大会简介5. 主办单位与嘉宾主办单位承办单位主讲嘉宾组委会 6. 征稿主题7. 论文出版8. 参会说明 1. 会议官方 2024 5th International Conference on Electronic communication and Artificial Intelligenc…
阅读更多...
2024年抖店什么类目赚钱？这八个类目最赚钱，想开店的快来瞅瞅！

2024年抖店什么类目赚钱？这八个类目最赚钱，想开店的快来瞅瞅！

哈喽~我是电商月月 做抖音小店的商家都知道&#xff0c;选品是非常重要的 那什么样的商品类型赚钱&#xff0c;哪些商品又适合新手操作呢? 今天我就给大家推荐几个热销类目&#xff0c;特别是最后两个&#xff0c;下半年说不定会小爆一把哦 一&#xff0e;日用百货 这个类…
阅读更多...
MySQl删除数据后释放空间

MySQl删除数据后释放空间

在MySQL中&#xff0c;当你删除表中的数据时&#xff0c;空间通常不会自动释放回操作系统。这是因为MySQL为了性能而保留了这些空间。如果你确实需要释放这些空间&#xff0c;可以使用OPTIMIZE TABLE命令&#xff0c;它会重建表并释放未使用的空间。 sqlOPTIMIZE TABLE your_t…
阅读更多...
为什么3d重制变换模型会变形？---模大狮模型网

为什么3d重制变换模型会变形？---模大狮模型网

3D建模和渲染过程中&#xff0c;设计师经常会遇到一个让人头疼的问题&#xff0c;那就是模型在进行重制变换后出现的意外变形。这种变形不仅影响了模型的外观和质量&#xff0c;也给设计工作带来了额外的麻烦。本文将深入探讨3D模型进行重制变换后出现变形的原因&#xff0c;帮…
阅读更多...
Pytorch基础：torch.cuda.set_device函数

Pytorch基础：torch.cuda.set_device函数

相关阅读 Pytorch基础https://blog.csdn.net/weixin_45791458/category_12457644.html?spm1001.2014.3001.5482 torch.cuda.set_device函数用于设置当前使用的cuda设备&#xff0c;在当拥有多个可用的GPU且能被pytorch识别的cuda设备情况下&#xff08;环境变量CUDA_VISIBLE_…
阅读更多...
【软考高项】四十六、项目管理科学计算之运筹学

【软考高项】四十六、项目管理科学计算之运筹学

1、线性规划问题 解题思路&#xff1a; 先把文字转化成图表 最快方式应该是把第一题的4个答案直接代入计算&#xff0c;很快得知X2时利润最大。 A0时&#xff0c;利润5*630 A2时&#xff0c;利润2*25*634 A4时&#xff0c;利润4*23*523 A6时&#xff0c;利润4*2(因为甲的…
阅读更多...
【STM32HAL库】DAC输出0-3.3v

【STM32HAL库】DAC输出0-3.3v

一、简要介绍一下DAC DAC也有分辨率&#xff0c;转换时间&#xff0c;精度等 分辨率常见为8或12位的 转换时间F1&#xff0c;F4,F7都是3us左右&#xff0c;而H7系列是1.7us 1.DAC框图 2.数据格式&#xff08;对齐方式&#xff09; 3.触发源 4.可以发送DMA请求 注意&#xff…
阅读更多...
train_gpt2.c

train_gpt2.c

llm.c/train_gpt2.c at master karpathy/llm.c (github.com) 源码 /* This file trains the GPT-2 model. This version is the clean, minimal, reference. As such: - it runs on CPU. - it does not make the code too complex; it is readable. - it does not use any p…
阅读更多...
代码随想录第五十一天|最长递增子序列、最长连续递增序列、最长重复子数组

代码随想录第五十一天|最长递增子序列、最长连续递增序列、最长重复子数组

题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09; 题目链接&#xff1a;. - 力扣&#xff08;LeetCode&#xff09;
阅读更多...
基于STM32H750的DCMI接口OV5640摄像头条码识别

基于STM32H750的DCMI接口OV5640摄像头条码识别

好久没写文章了&#xff0c;闭上眼睛&#xff0c;算了一下&#xff0c;大概有十年了&#xff0c;近来接到一个项目&#xff0c;需要做条码识别&#xff0c;客户要求用MCU做&#xff0c;理由成本低、价格可控。 于是乎&#xff0c;打开某宝软件&#xff0c;搜索后发现STM32H7/ST…
阅读更多...
Pygame简单入门教程（绘制Rect、控制移动、碰撞检测、Github项目源代码）

Pygame简单入门教程（绘制Rect、控制移动、碰撞检测、Github项目源代码）

Pygame简明教程 引言&#xff1a;本教程中的源码已上传个人Github: GItHub链接 视频教程推荐&#xff1a;YouTube教程–有点过于简单了 官方文档推荐&#xff1a;虽然写的一般&#xff0c;但还是推荐&#xff01; Navigator~ Pygame简明教程安装pygame一、代码框架二、案件输入…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023