axios案例应用

news2024/12/23 17:56:04

1、Spring概述

Spring 是分层的 Java SE/EE 应用 full-stack 轻量级开源框架，以 IoC(Inverse Of Control: 反转控制)和 AOP(Aspect Oriented Programming:面向切面编程)为内核，提供了展现层 Spring MVC 和持久层。Spring JDBC 以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多 著名的第三方框架和类库，逐渐成为使用最多的 Java EE 企业应用开源框架
在这里插入图片描述

2、spring发展历程
1997 年 IBM 提出了 EJB 的思想
1998 年，SUN 制定开发标准规范 EJB1.0
1999 年，EJB1.1 发布
2001 年，EJB2.0 发布
2003 年，EJB2.1 发布
2006 年，EJB3.0 发布
Rod Johnson(spring之父) ，Expert One-to-One J2EE Design and Development(2002) 阐述了 J2EE 使用 EJB 开发设计的优点及解决方案。Expert One-to-One J2EE Development without EJB(2004) 。阐述了 J2EE 开发不使用 EJB 的解决方式(Spring 雏形) ，2017年9月份发布了spring的最新版本spring 5.0通用版(GA)

3、spring的优势

				(1)、方便解耦，简化开发：IOC

					通过 Spring 提供的 IoC容器，可以将对象间的依赖关系交由 Spring进行控制，避免硬编码所造 成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这					些很底层的需求编写代码，可以更专注于上层的应用。

				(2)、AOP编程的支持

					通过 Spring 的 AOP 功能，方便进行面向切面的编程，许多不容易用传统 OOP实现的功能可以。通过 AOP轻松应付。

				(3)、声明式事务的支持

					可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理， 提高开发效率和质量。

				(4)、方便程序的测试

					可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可 做的事情。

				(5)、方便集成各种优秀框架

					Spring 可以降低各种框架的使用难度，提供了对各种优秀框架(Struts、Hibernate、Hessian、Quartz等)的直接支持

				(6)、降低 JavaEE API 的使用难度

					Spring 对 JavaEE API(如 JDBC、JavaMail、远程调用等)进行了薄薄的封装层，使这些 API 的 使用难度大为降低。

				(7)、Java 源码是经典学习范例

					Spring 的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对 Java设计模式灵活运用以 及对 Java技术的高深造诣。它的源代码无疑是 Java技术的最佳实践的范例。

4、spring体系结构

在这里插入图片描述

二、Spring入门案例のHelloWorld

和大多数框架一样，使用第三方的框架，基本步骤：

1.引入框架使用需要的依赖******

2.配置文件（格式大多数xml格式或yaml、properties）

3.spring提供的API完成对象的获取和实例化

案例代码

  • pom.xml导入spring依赖

      <dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-beans</artifactId>
    <version>5.3.28</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.28</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.28</version>
</dependency>

  • spring配置文件

    <?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           https://www.springframework.org/schema/beans/spring-beans.xsd
                           http://www.springframework.org/schema/context
                           https://www.springframework.org/schema/context/spring-context.xsd
                           http://www.springframework.org/schema/aop
                           https://www.springframework.org/schema/aop/spring-aop.xsd
                           http://www.springframework.org/schema/tx
                           https://www.springframework.org/schema/tx/spring-tx.xsd">
    <!--  spring配置文件中配置对象的基本信息 -->
    <bean id="myUserDaoImpl1" class="com.woniu.dao.impl.UserDaoImpl" scope="prototype"></bean>
</beans>

  • 创建Person类型，利用spring获取Person对象
    通过案例代码的运行，我们会发现，不用写new UserDaoImpl()也能得到UserDaoImpl对象。解决了传统自己new对象的“硬编码”问题。

思考1：Spring中获取的对象是单例的吗？

案例分析

  • UserDaoImpl.java

  •   public class UserDaoImpl implements UserDao {
  public UserDaoImpl() {
      System.out.println("UserDaoImpl构造器被调用");
  }

  @Override
  public int insert() {
      System.out.println("链接mysql数据库，完成用户信息");
      return 0;
  }

    }

  • 测试类

  •   @Test  
public void  mt01(){
 	ApplicationContext factory=new ClassPathXmlApplicationContext("ApplicationContext.xml");

  //获取特定的对象 spring容器装的对象，默认：单例的！！！
  Object obj1 = factory.getBean("myUserDaoImpl1");
  Object obj2 = factory.getBean("myUserDaoImpl1");
  System.out.println("obj1内存地址:"+obj1);
  System.out.println("obj2内存地址:"+obj2);

  System.out.println(obj1==obj2);

    }

  • 测试结果
    在这里插入图片描述

观察测试代码运行结果，可以得出结论：默认情况下，所有由Spring构建的对象都是单例对象。

思考2：如何从Spring容器得到一个多例对象呢？

我们可以通过设置bean标签的scope属性来改变对象在Spring容器中的创建方式：

<bean id="userDao" class="cn.woniu.dao.UserDao" scope="prototype"></bean>
  • 作用：
    用于注册对象信息，让 spring 来创建。
    默认情况下 它调用的是类中的无参构造函数。如果没有无参构造函数则不能创建成功。
  • 属性：
    id：给对象在容器中提供一个唯一标识。用于获取对象。
    class：指定类的全限定类名。用于反射创建对象。默认情况下调用无参构造函数。
    scope：指定对象的作用范围。
    1、singleton :默认值，单例的.
    2、prototype :多例的.
    3、request :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 request 域中
    4、session :WEB 项目中,Spring 创建一个 Bean 的对象,将对象存入到 session 域中.
    5、global session :WEB 项目中,应用在 Portlet 环境 .如果没有 Portlet 环境那么 globalSession 相当于 session.

三、解读Helloworld案例代码

1、ApplicationContext是什么？

我们可以把ApplicationContext理解成是一个装载对象的“大容器”，其本质就是一个对象工厂。借助IDEA快捷键Alt+Ctrl+U可以看到ApplicationContext实现过的所有父接口：
在这里插入图片描述

2、BeanFactory和ApplicationContext的区别【常见面试题】

ApplicationContext底层就是对象工厂（即BeanFactory）。Spring提供两种创建对象工厂的方式（BeanFactory和ApplicationContext两个接口）。这种方式创建对象工厂时有什么区别呢？

案例演示ApplicationContext

  • 在UserDaoImpl类中添加无参构造方法：代码略

  • 测试方法
    //1.创建spring ioc容器 ApplicationContext可以理解成是Spring容器，本质其实就是BeanFactory,职责就是负责获取对象
    //ApplicationContext:工厂建好，立马将需要工厂管理对象也一起建好
    ApplicationContext cnt=new ClassPathXmlApplicationContext(“spring-config.xml”);

  • 结果如下：
    在这里插入图片描述

UserDaoImpl对象的构造器被调用，意味着UserDaoImpl对象在创建ApplicationContext时就被创建

案例演示BeanFactory

  • 修改测试方法
    //1.创建spring ioc容器 ApplicationContext可以理解成是Spring容器，本质其实就是BeanFactory,职责就是负责获取对象
    //BeanFactory延迟加载（也称为懒加载）创建工厂对象时，不会帮我们把工厂内部对象创建
    Resource resource=new ClassPathResource(“spring-config.xml”);
    BeanFactory cnt=new XmlBeanFactory(resource);

  • 结果如下：

    控制台什么也没输出，也就是UserDaoImpl对象的构造器没有调用，意味着UserDaoImpl对象在创建BeanFactory时没有被创建

通过以上案例对比，我们可以得出以下结论：

BeanFactory：SpringIoc容器基本实现，是Spring内部的使用接口，不提供开发人员进行使用。
BeanFactory对象工厂实现的特点是：
构建核心容器时，创建对象采取的策略是延迟加载的方式，什么时候调用getBean根据id获取对象了，什么时候才真正创建对象。适用于多例模式

ApplicationContext：ApplicationContext是BeanFactory接口的子接口，提供更多更强大的功能，一般由开发人员进行使用。
ApplicationContext实现的特点是：
在构建核心容器时，创建对象采取的策略是立即加载的方式，只要一读取完配置文件就马上创建配置文件中的配置对象。适用于单例模式

3、ApplicationContext的三个实现类【理解】

在入门Helloworld案例中，我们实例化spring的工厂对象时，使用的是ClassPathXmlApplicationContext对象，其实在ApplicationContext的继承体系中，除了ClassPathXmlApplicationContext这个实现类以外，还有另外两个子类也可以完成ApplicationContext对象工厂的实例化。

提示：idea中通过选中类，通过ctrl+H可以查看向下派生的继承体现，通过ctrl+alt+u可以查看该类向上的继承体系结构。

		在ApplicationContext对象上按ctrl+h查看该类的结构

在这里插入图片描述

ClassPathXmlApplicationContext:加载类路径下的配置文件，要求配置文件必须在类路径下（常用）*****
FileSystemXmlApplicationContext:加载磁盘任意路径下的配置文件(必须有访问权限) 
AnnotationConfigApplicationContext:读取注解配置容器

4、bean 的作用范围和生命周期 【面试题】

1、单例对象：scope="singleton"
  一个应用只有一个对象的实例。它的作用范围就是整个应用。
  生命周期：
   对象出生：当应用加载，创建容器时，对象就被创建了。
   对象活着：只要容器在，对象一直活着。 
   对象死亡：当应用卸载，销毁容器时，对象就被销毁了。

2、多例对象：scope="prototype"
  每次访问对象时，都会重新创建对象实例。
  生命周期：
   对象出生：当使用对象时，创建新的对象实例。不使用就不创建
   对象活着：只要对象在使用中，就一直活着。
   对象死亡：当对象长时间不用时，被 java 的垃圾回收器回收了。

案例演示：bean的生命 周期

		创建StudentService类，在该类中添加：一个构造方法、一个init方法、一个destory方法

public class StudentService {
    //构造方法
    public StudentService(){
        System.out.println("创建对象实例");
    }

    //初始化方法
    public void init(){
        System.out.println("对象被创建了");
    }

    //销毁
    public void destory(){
        System.out.println("对象被销毁了");
    }
}

配置spring-config.xml

<!--  实例化StudentService  -->
    <bean id = "studentService"
          class="cn.woniu.service.StudentService"
          scope="singleton"
          init-method="init"
          destroy-method="destory">
    </bean>

创建测试方法
在这里插入图片描述

	我们发现，在===========上面时，对象就已经被创建了，这是单例对象的特点，立即加载，而且执行了studnetService类的init方法，但是我们并没有看到执行destory方法。原因很简单：当测试方法执行完时，线程结束，此时容器销毁，容器销毁意味着创建的单例对象也要销毁，只是此时没来得及打印。要想看到效果，我们需要手动让容器销毁，调用容器的close方法，此时对象就会销毁，即执行destory方法

在这里插入图片描述

如果我们把配置文件的对象改成多例模式呢？其它的代码不变

<!--  实例化StudentService  -->
    <bean id = "studentService"
          class="cn.woniu.service.StudentService"
          scope="prototype"
          init-method="init"
          destroy-method="destory">
    </bean>

改为多例模式后发现对象是懒加载的方式，即在用到的时候才会创建，而且我们手动关闭容器的时候也不会调用destory方法，原因很简单，多例对象的死亡是由java垃圾回收器回收的，不受容器管理。

四 IOC

IOC容器负责bean管理。什么是bean管理？从两个方面来理解：

  1. Spring容器负责为java项目创建对象（即IOC）
  2. Spring容器负责为创建的对象注入属性值（即DI）

Bean管理操作的方式有：

  • 基于xml配置文件方式实现
  • 基于注解方式实现
  • 通过JavaConfig配置bean

IOC概念

IOC： Inversion Of Control 控制反转。

以前：java程序使用对象：开发人员 new 对象 正向控制

spring：java程序使用对象：找Spring的ApplicationContext对象拿对象

翻译：new对象称为开发人员对对象的控制，将以前程序员自己new对象“权利” 交个Spring的spring容器统一管理的现象就是控制的权利反转了。所以，在spring中IOC的主要作用就是利用spring容器完成不同类对象的创建【实体类不会通过spring的ioc完成创建】进而解决程序中new对象时硬编码的问题。

IOC只解决程序间的依赖关系，除此之外没有任何功能

如何使用ioc完成对象创建呢？通常步骤有：

1.配置文件利用<bean></bean>配置你要spring容器管理的对象
2.获取spring工厂对象【或spring容器】
3.调用getBean根据id获取对象即可。

五 DI

DI:Dependency Injection 依赖注入

翻译：IOC只管对象创建，DI负责对象属性赋值

DI常用方式

  • setter注入方式
  • 构造器注入方式

setter注入方式

Set注入就是在类中提供需要注入成员的 setter方法，通过调用setter完成属性赋值

案例

Person.java代码

@ToString
public class Person {
    private Integer id;//1
    private String name;//张三丰

    public Person() {
        System.out.println("Person的构造器被调用了");
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

在这里插入图片描述

构造器注入

注入属性值的对象提供了带参构造器，而且还保持类有无参构造器

案例

Person.java添加构造器

public class Person {
    private Integer id;//1
    private String name;//张三丰

    public Person(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    public Person() {
    }
}

在这里插入图片描述

使用c命名空间和p命名空间简化构造器赋值和setter赋值【了解】

使用步骤：
在这里插入图片描述

  • xml文件根标签中引入p和c命名空间
  • 使用c:和p:作为前缀实现赋值
    在这里插入图片描述

不同数据类型的属性注入

Spring不管entity类型，主要对三层架构对象进行ioc和di管理

8种基本类型及对应的包装类及String类型

赋值方式都是通过value属性赋值

使用setter赋值,完整语法
<property name="属性名" value="属性值"/>
使用构造器赋值,完整语法
<constructor-arg name/index/type="形参名" value="属性值"/>

自定义对象类型

使用setter赋值,完整语法
<property name="属性名" ref="引用的对象ID"/>
使用构造器赋值,完整语法
<constructor-arg name/index/type="形参名" ref="引用的对象ID"/>

在这里插入图片描述

集合和数组类型【了解】

常见类型：数组、List集合、Set集合、Map集合、Properties集合
在这里插入图片描述
在这里插入图片描述在这里插入图片描述

利用c命名空间和p命名空间简化属性赋值【了解】

c命名空间简化构造器注入方式，举例：
在这里插入图片描述

p命名空间简化setter注入方式

使用步骤：

  • xml文件根标签中引入p和c命名空间
  • 使用c:和p:作为前缀实现赋值
    在这里插入图片描述

六 DI自动装配机制【理解】

自动装配是根据自动的装配规则（byName属性名称或byType属性类型），Spring自动将匹配的属性值进行注入的方式。自动装配是spring DI的一种方式。

在Spring中有三种自动装配的方式：

  • 在xml中显式配置【理解】
  • 在javal类中显示配置【Spring5+的新特性】【重点】
  • 隐式的自动装配【注解方式，重点】

利用XML配置完成自动装配【理解】
在这里插入图片描述

自动装配常见异常

使用byType进行装配时，如果一个类型可以找到多个Bean对象，就会出现以下异常：

解决方案：利用byName进行装配

七 spring提供注解完成IOC和DI功能【实际开发都是注解完成ioc和di 重点】

IOC注解

@Component,@Repository,@Service,@Controller标记在类上，实现这个类由spring容器负责对象管理

作用类似xml配置

@Component:标注三层架构以外的类，比如全局异常、工具类、redis或minio工具类

spring为@Component衍生了三个注解，三个注解作用跟@Component一模一样，但是从词意来看，阅读性比@Component更好

@Repository：一般用在持久层
@Service：一般用在业务层
@Controller:一般用在控制器层

DI注解

@Value

完成8种基本类型和String类型的属性值注入。@Value的作用等价于以下代码：

<property name="" value='属性值'/> 
或
<constructor-arg name/index/type="" value="属性值"/>

@Autowired

完成自定义类型属性注入。@Autowired的作用等价于以下代码：

<bean autowired="byName/byType"/>

@Autowired默认先根据byType,如果byType装配失败，退而其次，使用byName再装配，如果byName也失败，直接抛出异常

跟@Autowired注解一样，也可以为引用类型的对象属性注入值的的注解还有以下两个：

@Resource

@Resource注解与@Autowired注解的作用是一样的，都是用来为bean对象注入值的，唯一的区别是@Resource注解要根据实例化的bean名称为bean对象注入值。@Resource是javax包下注解，不是spring官方注解。

@Resource(value=“byName属性名”)

@Quanifier

byName注入，是spring提供的byName注解，它在给字段注入时不能独立使用，必须和@Autowire 一起使用，表示在自动按照类型注入的基础之上，再按照 Bean 的id 注入；@Quanifier也给方法形参注入，注入时可以独立使用。

语法：

@Quanifier(value=“byName的名称”)

小结注解开发

spring提供的注解，依据注解作用和使用位置不同，划分为三类：
1.注解在类上，作用IOC创建对象的作用：
  @Component   @Repository  @Service  @Controller

2.注解在属性上，作用DI属性注入值的作用：
  @Resource:byName
  @Quanifier:默认byName,但是不能独立使用在属性上，必须@Autowired结合使用
  @AutoWired：默认先byType,byType失败，再byName

  @Value:注入八种基本类型和String类型

3.注解在类上，设置对象单例模式还是多例模式，设置对象使用范围：[了解]
  @Scope(设置对象使用范围：propotype  singleton  session  request)

使用案例

  • UserDaoImpl.java

    //这个类是否会被别的层的类使用，如果会，这个类交给spring容器管理
    @Repository
    public class UserDaoImpl implements UserDao {
    @Override
    public int insert() {
    System.out.println(“连接mysql数据库，执行insert操作…”);
    return 0;
    }
    }

  • UserServiceImpl.java

    @Service
    public class UserServiceImpl implements UserService {
    //DI注入对象，注入方式
    @Autowired
    private UserDao userDao;
    @Override
    public void add() {
    userDao.insert();
    }
    }

  • UserController.java

    /**

    • 注解开发里面，如果使用setter注入方式，类中不需要提供setter都可以注入成功
      */
      @Controller
      public class UserController {
      @Autowired
      private UserService userService;
      public void service(){
      userService.add();
      }
      }

  • 单元测试

    @Test
    public void service() {
    ApplicationContext cnt=new ClassPathXmlApplicationContext(“spring-config.xml”);
    UserController controller = cnt.getBean(“userController”, UserController.class);
    controller.service();

    }

当我们再为UserDao接口提供一个新的实现类，代码如下所示：

  • UserDaoImpl2.java

    @Repository
    public class UserDaoImpl2 implements UserDao {
    public UserDaoImpl2() {
    System.out.println(“UserDaoImpl2”);
    }

      @Override
  public int insert() {
      System.out.println("连接oracle数据库，执行insert操作...");
      return 0;
  }

    }

重新执行单元测试，会发现控制台爆出异常：

如何解决呢？可以借助@Resource或@Qualifier指定注入对象的名称，代码如下所示：

  • UserServiceImpl.java

    @Service
    public class UserServiceImpl implements UserService {
    @Resource(name = “userDaoImpl2”)//name属性设置注入对象的属性名，如果属性名和name注入的名称一致的，name可以不赋值
    private UserDao userDao;
    @Override
    public void add() {
    userDao.insert();
    }
    }

或

@Service
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userDaoImpl") //默认byName,但是注入属性时不能独立使用，必须和@Autowired一起结合使用
    private UserDao userDao;
    @Override
    public void add() {
        userDao.insert();
    }
}

如果，我们希望UserDaoImpl2是一个多例对象，也可以在类上通过@Scope注解注解对象的使用范围：

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Repository
public class UserDaoImpl2 implements UserDao {
    public UserDaoImpl2() {
        System.out.println("UserDaoImpl2");
    }

    @Override
    public int insert() {
        System.out.println("连接oracle数据库，执行insert操作...");
        return 0;
    }
}

测试多例模式

@Test
    public void test02() {
        ApplicationContext cnt=new ClassPathXmlApplicationContext("spring-config.xml");
        Object o1 = cnt.getBean("userDaoImpl2");
        Object o2 = cnt.getBean("userDaoImpl2");
        Object o3 = cnt.getBean("userDaoImpl2");

    }

控制台输出结果如下图所示：

扩展了解：程序的耦合和解耦

1、藕合和解藕的思路

			藕合就是程序间的依赖关系。解藕就是降低程序间的依赖关系。在开发过程中应做到编译期不依赖，运行时再依赖

			解藕思路：

				使用反射来创建对象，而不使用new关键字

				 通过读取配置文件来获取要创建的对象全限定名

2、曾经代码的问题

	创建java控制台程序

创建Dao类

创建service并调用Dao

创建测试类并调用service

层与层之间的关系通过new来实现调用，并且new对象时需要导入该对象所在的正确的包名，否则报错。这种关系称为藕合关系。

3、工厂类和配置文件解决藕合问题

a、创建properties属性文件

b、创建工厂类

package cn.woniu.utils;

import java.io.InputStream;
import java.util.Properties;

/**
 * 对象工厂
 */
public class BeanFactory {
    //定义一个Properties对象
    private static Properties properties;
    //使用静态代码块为Properties对象赋值
    static {
        try {
            properties = new Properties();
            //获取Properties文件流对象
            InputStream input = BeanFactory.class.getClassLoader().getResourceAsStream("bean.properties");
            properties.load(input);

        } catch (Exception e) {
            throw new ExceptionInInitializerError("初始化Properties属性出错"+e.getMessage());
        }
    }

    /**
     * 根据Bean名称获取Bean对象
     *
     * @param beanName
     */
    public static Object getBean(String beanName) {
        Object bean = null;
        try {
            String beanPath = properties.getProperty(beanName);
            bean = Class.forName(beanPath).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return bean;
    }
}

c、使用工厂类调用各层

 service调用dao

测试调用service

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

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

相关文章

C++进阶：C++11(列表初始化、右值引用与移动构造移动赋值、可变参数模版...Args、lambda表达式、function包装器)

C++进阶：C++11(列表初始化、右值引用与移动构造移动赋值、可变参数模版...Args、lambda表达式、function包装器)

C进阶&#xff1a;C11(列表初始化、右值引用与移动构造移动赋值、可变参数模版…Args、lambda表达式、function包装器) 今天接着进行语法方面知识点的讲解 文章目录 1.统一的列表初始化1.1&#xff5b;&#xff5d;初始化1.2 initializer_listpair的补充 2.声明相关关键字2.1a…
阅读更多...
STM32——DAC篇（基于f103)

STM32——DAC篇（基于f103)

技术笔记&#xff01; 一、DAC简介&#xff08;了解&#xff09; 1.1 DAC概念 传感器信号采集改变电信号&#xff0c;通过ADC转换成单片机可以处理的数字信号&#xff0c;处理后&#xff0c;通过DAC转换成电信号&#xff0c;进而实现对系统的控制。 1.2 DAC的特性参数 1.3…
阅读更多...
amis-editor 低代码可视化编辑器开发 和 使用说明

amis-editor 低代码可视化编辑器开发 和 使用说明

1.amis-editor可视化编辑器 React版本&#xff08;推荐&#xff09;&#xff1a; GitHub - aisuda/amis-editor-demo: amis 可视化编辑器示例 https://aisuda.github.io/amis-editor-demo 建议使用react版本&#xff0c;好维护&#xff0c;升级版本更新package.json中对应版本…
阅读更多...
Property xxx does not exist on type ‘Window typeof globalThis‘ 解决方法

Property xxx does not exist on type ‘Window typeof globalThis‘ 解决方法

问题现象 出现以上typescript警告&#xff0c;是因为代码使用了window的非标准属性&#xff0c;即原生 window 对象上不存在该属性。 解决办法 在项目 根目录 或者 src目录 下新建 xxx.d.ts 文件&#xff0c;然后进行对该 属性 进行声明即可。 注意&#xff1a;假如xxx.d.ts文…
阅读更多...
【vue】封装的天气展示卡片，在线获取天气信息

【vue】封装的天气展示卡片，在线获取天气信息

源码 <template><div class"sen_weather_wrapper"><div class"sen_top_box"><div class"sen_left_box"><div class"sen_top"><div class"sen_city">山东</div><qctc-time cl…
阅读更多...
【Text2SQL 经典模型】X-SQL

【Text2SQL 经典模型】X-SQL

论文&#xff1a;X-SQL: reinforce schema representation with context ⭐⭐⭐⭐ Microsoft, arXiv:1908.08113 X-SQL 与 SQLova 类似&#xff0c;使用 BERT style 的 PLM 来获得 representation&#xff0c;只是融合 NL question 和 table schema 的信息的方式不太一样&#…
阅读更多...
Keil MDK map文件学习笔记

Keil MDK map文件学习笔记

Keil MDK map文件学习笔记 map文件组成1.Section Cross References段交叉引用2.Removing Unused input sections from the image移除无用的段3.Image Symbol Table镜像符号表局部符号表全局符号表 4.Memory Map of the image镜像存储器映射ROM区执行域RAM区执行域 5. Image com…
阅读更多...
C#学习指南：重要内容与实用技巧

C#学习指南：重要内容与实用技巧

学习C#编程是一段充满挑战但又非常充实的旅程。以下是我在学习过程中积累的一些经验&#xff0c;希望能对大家有所帮助。 一、掌握基础概念 类及其成员 C#中的类是编程的基础模块。理解类的结构、属性、方法和构造函数是至关重要的。每个类都有其特定的功能&#xff0c;学会如…
阅读更多...
Milvus 使用过程中的常见问题集锦

Milvus 使用过程中的常见问题集锦

引言 在使用Milvus的过程中&#xff0c;可能会遇到一些常见问题。这些问题可能涉及到配置、查询、数据同步等方面。 常见问题 以下是一些可能遇到的常见问题及其解决方法&#xff1a; 查询结果不正确&#xff1a; 可能原因&#xff1a;Milvus内部缓存与数据不一致&#xff0…
阅读更多...
【数据结构】哈夫曼树和哈夫曼编码

【数据结构】哈夫曼树和哈夫曼编码

一、哈夫曼树 1.1 哈夫曼树的概念 给定一个序列&#xff0c;将序列中的所有元素作为叶子节点构建一棵二叉树&#xff0c;并使这棵树的带权路径长度最小&#xff0c;那么我们就得到了一棵哈夫曼树&#xff08;又称最优二叉树&#xff09; 接下来是名词解释&#xff1a; 权&a…
阅读更多...
APISIX-简单使用

APISIX-简单使用

APISIX-简单使用 这个工具还是很不错的&#xff0c;可视化的配置很清晰 &#xff0c; 想用NGINX的配置模式也是可以的&#xff0c;就是要去修改配置文件了。 APISIX&#xff0c;一个很不错的可视化工具&#xff0c;用来代替Nginx相当不错&#xff0c;可作为Nginx的平替方案&…
阅读更多...
Leecode热题100---45：跳跃游戏②

Leecode热题100---45：跳跃游戏②

题目&#xff1a; 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。 返回到达 nums[n - 1] 的最小跳跃次数。 思路&#xff1a; 如果某一个作为 起跳点 的格子可以跳跃的距离是 3&#xff0c;那么表示后面…
阅读更多...
解耦:哪些方法可以用来解耦代码

解耦:哪些方法可以用来解耦代码

目录 1.引用 2.为何解耦如此重要 3.如何判断代码是否需要解耦 4.如何给代码解耦 5.思考题 1.引用 前面我们曾经讲到&#xff0c;重构可以分为大型重构和小型重构。小型重构的主要目的是提高代码的可读性&#xff0c;大型重构的主要目的是解耦。本节讲解如何对代码进行解耦…
阅读更多...
用python为目录下的文件生成索引

用python为目录下的文件生成索引

好久没写文章了。 有一个需求&#xff1a; 我的一个目录下有很多的.html文件&#xff0c; 每个html会包含一些image &#xff0c;但都在各自的目录中。 .html特别多&#xff0c;有好几百个&#xff0c;我需要一个index.hmtl把这些html全部索引起来&#xff0c;使得我一个点击&a…
阅读更多...
计算机如何将输入文字显示出来的？渲染Image rendering

计算机如何将输入文字显示出来的？渲染Image rendering

1.文字渲染的简单理解 渲染图像&#xff0c;可以理解为用cpu/gpu构造出原本不存在的图像。比如输入计算机的英文字符都是ASCII码&#xff0c;而我们在屏幕上看到显示的字符对应的应该是RGB/YUV的像素。计算机把ASCII字符转化成像素的过程就是文字渲染。又比如我们GPU用多个2D图…
阅读更多...
全同态加密生态项目盘点：FHE技术的崛起以及应用

全同态加密生态项目盘点：FHE技术的崛起以及应用

撰文&#xff1a;Chris&#xff0c;Techub News 在当今数字化的时代&#xff0c;隐私保护已成为一个全球性的焦点话题&#xff0c;特别是在加密货币和区块链技术快速发展的背景下。虽然当前的隐私技术在保护数据安全方面多有欠缺&#xff0c;引发了广泛的关注和批评&#xff0c…
阅读更多...
如何彻底搞懂装饰器（Decorator）设计模式？

如何彻底搞懂装饰器（Decorator）设计模式？

对于任何一个软件系统而言&#xff0c;往现有对象中添加新功能是一种不可避免的实现场景&#xff0c;但这一实现过程对现有系统的影响可大可小。从架构设计上讲&#xff0c;我们也知道存在一个开闭原则&#xff08;Open-Closed Principle&#xff0c;OCP&#xff09;&#xff0…
阅读更多...
中文信息期刊投稿邮箱

中文信息期刊投稿邮箱

《中文信息》杂志是国家新闻出版总署批准的国家级刊物&#xff08;月刊&#xff09;&#xff0c;国内外公开发行&#xff0c;大十六开印刷。本刊主要反映我国中文信息处理的学术水平&#xff0c;重点刊登科技、经济、教育等领域的基础理论、科研与应用技术的学术论文&#xff0…
阅读更多...
使用Coding部署项目

使用Coding部署项目

coding概述&#xff1a;提供一站式开发协作工具&#xff0c;帮助研发团队快速落地敏捷开发与 DevOps 开发方式&#xff0c;实现研发效能升级 一、创建项目 省略 详细文档&#xff1a;https://g-mnbk6665.coding.net/quickstart 二、SSH连接 关于ssh相关命令 重启SSH服务 s…
阅读更多...
2023蓝桥杯大赛软件类省赛Java大学B组G题 买二增一 队列的简单应用

2023蓝桥杯大赛软件类省赛Java大学B组G题 买二增一 队列的简单应用

用队列 Queue package Dduo; //Bhu Bigdata 1421 //Eslipse IDE 2020-08 //JDK 1.8 //2024/5/19 import java.util.Scanner; import java.math.BigInteger; import java.util.Arrays; import java.util.LinkedList; import java.util.Queue;public class Main {public static v…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023