Spring底层架构核心概念解析

news2025/1/14 1:32:51

BeanDefinition

BeanDefinition表示Bean定义,BeanDefinition中存在很多属性用来描述一个Bean的特点.比如:

  • beanClass:表示Bean类型
  • scope:表示Bean作用域,单例/原型等
  • lazyInit:表示Bean是否懒加载
  • initMethodName:表示Bean初始化时要执行的方法
  • destoryMethodName:表示Bean销毁时要执行的方法
  • …

再Spring中,我们经常会通过以下几种方式来定义Bean:

  1. <bean/>
  2. @Bean
  3. @Component/@Service/@Controller

这些可以称之为 申明式定义Bean.

还可以 编程式定义Bean,那就是直接通过BeanDefinition

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    // 生成一个BeanDefinition对象
    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
    // 设置beanClass为User.class
    beanDefinition.setBeanClass(User.class);
    // 注册到ApplicationContext中
    context.registerBeanDefinition("user",beanDefinition);
    System.out.println(context.getBean("user"));
}

// com.fanqiechaodan.entity.User@2034b64c

还可以通过BeanDefinition设置一个Bean的其他属性

// 设置作用域
beanDefinition.setScope(BeanDefinition.SCOPE_PROTOTYPE);
// 设置初始化方法
beanDefinition.setInitMethodName("init");
// 设置懒加载
beanDefinition.setLazyInit(true);

和申明式事务,编程式事务类似,通过<bean/>,@Bean,@Component等申明方式所定义的Bean,最终都会被Spring解析为对应的BeanDefinition对象,并放入Spring容器中.

BeanDefinitionReader

BeanDefinitionReader(BeanDefinition读取器),这些BeanDefinitionReader在使用Spring时用的少,但在Spring源码中用的多,相当于Spring的基础设置

AnnotatedBeanDefinitionReader

可以直接把某个类转换为BeanDefinition,并解析该类上的注解

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    AnnotatedBeanDefinitionReader beanDefinitionReader = new AnnotatedBeanDefinitionReader(context);
    // 将User.class解析为BeanDefinition
    beanDefinitionReader.register(User.class);
    System.out.println(context.getBean("user"));
}

注意:它能解析的注解是:@Conditional,@DependsOn,@Description,@Lazy,@Primary,@Role,@Scope

XmlBeanDefinitionReader

可以解析<bean/>标签

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(context);
    // 返回注册Bean的数量
    int i = beanDefinitionReader.loadBeanDefinitions("spring.xml");
    System.out.println(context.getBean("user"));
}

ClassPathBeanDefinitionScanner

ClassPathBeanDefinitionScanner是扫描器,但是它的作用与BeanDefinitionReader类似,它可以进行扫描,扫描某个包路径,对扫描的类进行解析,比如:扫描到的类如果存在@Component注解,那么就会把这个类解析为一个BeanDefinition.

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    ClassPathBeanDefinitionScanner beanDefinitionScanner = new ClassPathBeanDefinitionScanner(context);
    beanDefinitionScanner.scan("com.fanqiechaodan");
    System.out.println(context.getBean("userService"));
}

BeanFactory

BeanFactory表示Bean工厂,所以很明显,BeanFactory会负责创建Bean,并且提供获取Bean的API.

而ApplicationContext是BeanFactory的一种,在Spring源码中,是这么定义的:

public interface ApplicationContext extends EnvironmentCapable, ListableBeanFactory, HierarchicalBeanFactory,
		MessageSource, ApplicationEventPublisher, ResourcePatternResolver {
            // ...
}

首先,在Java中,接口时可以 多继承 的,我们发现ApplicationContext继承了ListableBeanFactory和HierarchicalBeanFactory,而ListableBeanFactory和HierarchicalBeanFactory都继承至BeanFactory,等同ApplicationContext继承了BeanFactory,ApplicationContext也是BeanFactory的一种,拥有BeanFactory支持的所有功能,不过ApplicationContext比BeanFactory更加强大,ApplicationContext还继承了其他接口,也就表示ApplicationContext还拥有其他的功能.比如MessageSource(国际化),ApplicationEventPublisher(事件发布)等等.

在Spring源码实现中,当我们new一个ApplicationContext时,其底层会new一个BeanFactory出来,当使用ApplicationContext的某些方法时,比如getBean(),底层调用的是BeanFactory的getBean().

在Spring源码中,BeanFactory接口存在一个非常重要的实现类:DefaultListableBeanFactory.所以我们可以直接来使用 DefaultListableBeanFactory,而不用使用ApplicationContext的某个实现类

public static void main(String[] args) {
    DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
    AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
    beanDefinition.setBeanClass(User.class);
    beanFactory.registerBeanDefinition("user",beanDefinition);
    System.out.println(beanFactory.getBean("user"));
}

DefaultListableBeanFactory是非常强大的,支持很多功能,可以通过查看DefaultListableBeanFactory的类继承实现结构来看

在这里插入图片描述

它实现了很多接口,表示它拥有很多功能:

  1. AliasRegistry:支持别名功能,一个名字可以对应多个别名
  2. BeanDefinitionRegistry:可以注册,保存,移出,获取某个BeanDefinition
  3. BeanFactory:Bean工厂,可以根据某个Bean的名字/类型/别名获取某个Bean对象
  4. SingletonBeanRegistry:可以注册,获取某个单例Bean
  5. SimpleAliasRegistry:它是一个类,实现了AliasRegistry接口中所定义的功能,支持别名
  6. ListableBeanFactory:在BeanFactory的基础上,增加了其他功能,可以获取所有BeanDefinition的beanNames,可以根据某个类型获取对应的beanNames,可以根据某个类型获取{类型:对应的Bean}的映射关系
  7. HierarchicalBeanFactory:在BeanFactory的基础上,增加了获取父BeanFactory的功能
  8. DefaultSingletonBeanRegisty:它是一个类,实现了SingletonBeanRegistry接口,拥有了直接注册,获取某个单例Bean的功能
  9. ConfigurableBeanFactory:在HierarchicalBeanFactory和SingletonBeanRegistry的基础上,添加了设置父BeanFactory,类加载器(表示可以指定某个类加载器进行类的加载),设置Spring EL表达式解析器(表示可以解析EL表达式),设置类型转化服务(表示可以进行类型转化),可以添加BeanPostprocessor(表示支持Bean的后置处理器),可以合并BeanDefinition,可以销毁某个Bean等等功能
  10. FactoryBeanRegistrySupport:支持了FactoryBean的功能
  11. AutowireCapableBeanFactory:直接继承了BeanFactory,在BeanFactory的基础上,支持创建Bean的过程中能对Bean进行自动装配
  12. AbstractBeanFactory:继承了FactoryBeanRegistrySupport,实现了ConfigurableBeanFactory,这个BeanFactory的功能已经很全面了,但是不能自动装配和获取beanNames
  13. ConfigurableListableBeanFactory:继承了ListableBeanFactory,AutowireCapableBeanFactory,ConfigurableBeanFactory
  14. AbstractAutowireCapableBeanFactory:继承了AbstractBeanFactory,实现了AutowireCapableBeanFactory拥有了自动装配的功能
  15. DefaultListableBeanFactory:直接或间接的继承/实现以上所有类或接口.所以DefaultListableBeanFactory的功能很强大

ApplicationContext

ApplicationContext是个接口,实际上也是一个BeanFactory,不过比BeanFactory更加强大,比如:

  1. HierarchicalBeanFactory:拥有获取父BeanFactory的功能
  2. ListableBeanFactory:拥有获取beanNames的功能
  3. ResourcePatternResolver:资源加载器,可以一次性获取多个资源(文件资源等等)
  4. EnvironmentCapable:可以获取运行时环境,没有设置运行时环境功能
  5. ApplicationEventPublisher:拥有广播事件的功能,没有添加事件监听的功能
  6. MessageSource:拥有国际化功能

ApplicationContext有两个比较重要的实现类:

  1. AnnotationConfigApplicationContext
  2. ClassPathXmlApplicationContext

AnnotationConfigApplicationContext

在这里插入图片描述

  1. ConfigurableApplicationContext:继承了ApplicationContext接口,增加了事件监听器,添加BeanFactoryPostProcessor,设置Environment,获取ConfigurableListableBeanFactory等功能
  2. AbstractApplicationContext:实现了ConfigurableApplicationContext接口
  3. GenericApplicationContext:继承了AbstractApplicationContext,实现了BeanDefinitionRegistry接口,拥有了所有ApplicationContext的功能,并且可以注册BeanDefinition,这个类内置了一个DefaultListableBeanFactory属性
  4. AnnotationConfigRegistry:可以单独注册某个类为BeanDefinition,可以处理该类上的@Configuration注解@Bean注解,同时可以扫描
  5. AnnotationConfigApplicationContext:继承了GenericApplicationContext,实现了AnnotationConfigRegistry接口,拥有了以上所有的功能

ClassPathXmlApplicationContext

在这里插入图片描述

它也是继承了AbstractApplicationContext,但是相对于AnnotationConfigApplicationContext而言,功能没有AnnotationConfigApplicationContext强大,比如不能注册BeanDefinition

国际化

先定义一个MessageSource

@Bean
public MessageSource messageSource() {
    ResourceBundleMessageSource res = new ResourceBundleMessageSource();
    res.setBasename("en_CN");
    res.setDefaultEncoding("UTF-8");
    return res;
}

en_CN.properties

test=测试

有了这个Bean,可以在任意想要进行国际化的地方使用MessageSource,同时因为ApplicationContext继承了MessageSource,也拥有国际化的功能

public static void main(String[] args) {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    System.out.println(context.getBean("messageSource"));
    System.out.println(context.getMessage("test", null, new Locale("en_CN")));
}

// 测试

资源加载

ApplicationContext还拥有资源加载的功能

public static void main(String[] args) throws IOException {
    ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    Resource userService = context.getResource("file://C:\\devspace\\fanqiechaodan-spring\\src\\main\\java\\com\\fanqiechaodan\\service\\UserService.java");
    System.out.println(userService.contentLength());
    System.out.println(userService.getFilename());
    System.out.println();

    Resource baidu = context.getResource("https://www.baidu.com/");
    System.out.println(baidu.contentLength());
    System.out.println(baidu.getURL());
    System.out.println();

    Resource spring = context.getResource("classpath:spring.xml");
    System.out.println(spring.contentLength());
    System.out.println(spring.getURL());
    System.out.println();

    Resource[] resources = context.getResources("classpath:com/fanqiechaodan/entity/*.class");
    for (Resource resource : resources) {
        System.out.println(resource.contentLength());
        System.out.println(resource.getURL());
    }
}
    
//  213
//  UserService.java
//  
//  2443
//  https://www.baidu.com/
//  
//  513
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/spring.xml
//  
//  296
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/com/fanqiechaodan/entity/Address.class
//  672
//  file:/C:/devspace/fanqiechaodan-spring/target/classes/com/fanqiechaodan/entity/User.class

获取运行时环境

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    Map<String, Object> systemEnvironment = context.getEnvironment().getSystemEnvironment();
    System.out.println(systemEnvironment);
    System.out.println();

    Map<String, Object> systemProperties = context.getEnvironment().getSystemProperties();
    System.out.println(systemProperties);
    System.out.println();

    MutablePropertySources propertySources = context.getEnvironment().getPropertySources();
    System.out.println(propertySources);

    System.out.println(context.getEnvironment().getProperty("sun.jnu.encoding"));
}

事件发布

先定义一个事件监听器

@Bean
public ApplicationListener applicationListener() {
    return event -> System.out.println("接收到一个事件");
}

在发布事件

public static void main(String[] args) {
    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
    context.publishEvent("aaa");
}

类型转化

在Spring源码中,有可能需要把String转成其他类型,所以在Spring源码中提供了一些技术来更方便的做对象的类型转化,关于类型转化Spring有很多应用.

PropertyEditor

这其实是JDK中提供的类型转化工具类

public class String2UserPropertyEditor extends PropertyEditorSupport implements PropertyEditor {

    @Override
    public void setAsText(String text) throws IllegalArgumentException {
        User user = new User();
        user.setName(text);
        this.setValue(user);
    }
}

public static void main(String[] args) {
    String2UserPropertyEditor editor = new String2UserPropertyEditor();
    editor.setAsText("testName");
    User user = (User) editor.getValue();
    System.out.println(user.getName());
}

如何向Spring中注册PropertyEditor:

@Bean
public CustomEditorConfigurer customEditorConfigurer(){
    CustomEditorConfigurer editorConfigurer = new CustomEditorConfigurer();
    Map<Class<?>, Class<? extends PropertyEditor>> map = new HashMap<>();
    // 表示String2UserPropertyEditor可以将String转换为User
    // 在Spring源码中,如果发现当前对象是String,需要的类型为User
    // 就会使用String2UserPropertyEditor来做类型转化
    map.put(User.class, String2UserPropertyEditor.class);
    editorConfigurer.setCustomEditors(map);
    return editorConfigurer;
}

假设现在有以下Bean:

@Service
public class UserService {

    @Value("test")
    private User user;

    public void test(){
        System.out.println(user.getName());
    }
}

使用@Value可以完成对User的赋值

ConversionService

Spring中提供的类型转化服务,它比PropertyEditor更强大

public class String2UserConverter implements ConditionalGenericConverter {
    @Override
    public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
        return sourceType.getType().equals(String.class) && targetType.getType().equals(User.class);
    }

    @Override
    public Set<ConvertiblePair> getConvertibleTypes() {
        return Collections.singleton(new ConvertiblePair(String.class, User.class));
    }

    @Override
    public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
        User user = new User();
        user.setName((String) source);
        return user;
    }
}

public static void main(String[] args) {
    DefaultConversionService conversionService = new DefaultConversionService();
    conversionService.addConverter(new String2UserConverter());
    User user = conversionService.convert("testName", User.class);
    System.out.println(user.getName());
}

如何向Spring中注册ConversionService

@Bean
public ConversionServiceFactoryBean conversionServiceFactoryBean(){
    ConversionServiceFactoryBean conversionServiceFactoryBean = new ConversionServiceFactoryBean();
    conversionServiceFactoryBean.setConverters(Collections.singleton(new String2UserConverter()));
    return conversionServiceFactoryBean;
}

TypeConverter

整合了PropertyEditor和ConversionService的功能,是Spring内部用的

public static void main(String[] args) {
    SimpleTypeConverter simpleTypeConverter = new SimpleTypeConverter();
    // 整合PropertyEditor
    //        simpleTypeConverter.registerCustomEditor(User.class,new String2UserPropertyEditor());
    // 整合ConversionService
    DefaultConversionService conversionService = new DefaultConversionService();
    conversionService.addConverter(new String2UserConverter());
    simpleTypeConverter.setConversionService(conversionService);
    User test = simpleTypeConverter.convertIfNecessary("test", User.class);
    System.out.println(test.getName());
}

OrderComparator

OrderComparator是Spring所提供的一种比较器,可以用来根据@Order注解或实现Ordered接口来执行值进行比较,从而可以进行排序

@Data
public class A implements Ordered {

    @Override
    public int getOrder() {
        return 1;
    }

}

@Data
public class B implements Ordered {
    @Override
    public int getOrder() {
        return 0;
    }

}

public static void main(String[] args) {
    A a = new A();
    B b = new B();

    OrderComparator orderComparator = new OrderComparator();
    System.out.println(orderComparator.compare(a,b));
    System.out.println();

    List list = new ArrayList<>();
    list.add(a);
    list.add(b);

    // 按order值升序排序
    list.sort(orderComparator);
    System.out.println(list);
}


//  1
//
//  [B(), A()]

另外,Spring中还提供了一个OrderComparator的子类:AnnotationAwreOrderComparator,它支持用@Oder来指定order值

@Data
@Order(1)
public class A {

}

@Data
@Order(0)
public class B {

}

public static void main(String[] args) {
    A a = new A();
    B b = new B();

    OrderComparator orderComparator = new OrderComparator();
    System.out.println(orderComparator.compare(a,b));
    System.out.println();

    List list = new ArrayList<>();
    list.add(a);
    list.add(b);

    // 按order值升序排序
    list.sort(orderComparator);
    System.out.println(list);
}


//  1
//
//  [B(), A()]

BeanPostProcessor

BeanPostProcessor表示Bean后置处理器

@Component
public class BeanPostProcessorDemo implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)){
            System.out.println("userService初始化前");
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        if ("userService".equals(beanName)){
            System.out.println("userService初始化后");
        }
        return bean;
    }
}

一个BeanPostProcessor可以在任意一个Bean的初始化之前以及初始化之后去额外的做一些用户自定义的逻辑,当然,我们可以通过判断beanName来进行针对性处理(针对某个Bean或某部分Bean)

我们可以通过定义BeanPostProcessor来干涉Spring创建Bean的过程.

BeanFactoryPostProcessor

BeanFactoryPostProcessor表示Bean工厂的后置处理器,其实和BeanPostProcessor类似,BeanPostProcessor是干涉Bean的创建过程,BeanFactoryPostProcessor是干涉BeanFactory的创建过程.

@Component
public class BeanFactoryProcessorDemo implements BeanFactoryPostProcessor {

    /**
     * 可以对beanFactory进行加工
     *
     * @param beanFactory
     * @throws BeansException
     */
    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("加工beanFactory");
    }
}

FactoryBean

我们可以通过BeanPostProcessor来干涉Bean创建的过程,如果想要一个Bean完全由我们来创建同样是可以的.

@Component
public class FactoryBeanDemo implements FactoryBean {
    
    @Override
    public Object getObject() throws Exception {
        return new UserService();
    }

    @Override
    public Class<?> getObjectType() {
        return UserService.class;
    }
}

通过上面这段代码,我们自己创建了一个UserService.并且它将成为Bean.但是通过这种方式创建的Bean.只会经过 初始化后,其他Spring的生命周期是不会经过的,比如依赖注入.而通过@Bean/@Service等等注解定义的Bean是会经过完整的Bean生命周期的.

ExcludeFilter和IncludeFilter

这两个Filter是Spring扫描过程中用来过滤的.ExcludeFilter表示 排除过滤器,IncludeFilter表示 包含过滤器.

/**
 * 扫描com.fanqiechaodan这个包下的所有类
 * 但是排除UserService即使它上面有@Component/@Service也不会注册成Bean
 */
@ComponentScan(value = "com.fanqiechaodan",
        excludeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class
        )})
public class AppConfig {
    
}

/**
 * 扫描com.fanqiechaodan这个包下的所有类
 * 包含UserService即使它上面没有@Component/@Service也会注册成Bean
 */
@ComponentScan(value = "com.fanqiechaodan",
        includeFilters = {@ComponentScan.Filter(
                type = FilterType.ASSIGNABLE_TYPE,
                classes = UserService.class
        )})
public class AppConfig {
    
}

FilterType分为:

  1. ANNOTATION:表示是否包含某个注解
  2. ASSIGNABLE_TYPE:表示是否是某个类
  3. ASPECTJ:表示是否符合某个Aspectj表达式
  4. REGEX:表示是否符合某个正则表达式
  5. CUSTOM:自定义

MetadataReader,ClassMetadata,AnnotationMetadata

在Spring中需要去解析类的信息,比如类名,类中的方法,类上的注解,这些都可以称之为类的元数据,所以Spring对类的元数据做了抽象,并提供了一些工具类.

MetadataReader表示类的元数据读取器,默认实现类为 SimpleMetadataReader

public static void main(String[] args) throws IOException {
    SimpleMetadataReaderFactory metadataReaderFactory = new SimpleMetadataReaderFactory();

    // 构造一个MetadataReader
    MetadataReader metadataReader = metadataReaderFactory.getMetadataReader("com.fanqiechaodan.service.UserService");

    // 得到了一个ClassMetadata,并获取类名
    ClassMetadata classMetadata = metadataReader.getClassMetadata();
    System.out.println(classMetadata.getClassName());

    // 获取一个AnnotationMetadata,并获取类上的注解信息
    AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();
    Set<String> annotationTypes = annotationMetadata.getAnnotationTypes();
    for (String annotationType : annotationTypes) {
        System.out.println(annotationType);
    }
}

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

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

相关文章

用于每个平台的最佳WordPress LMS主题

用于每个平台的最佳WordPress LMS主题

你已选择在 WordPress 上构建学习管理系统 (LMS)了。恭喜&#xff01; 你甚至可能已经选择了要使用的 LMS 插件&#xff0c;这已经是成功的一半了。 现在是时候弄清楚哪个 WordPress LMS 主题要与你的插件配对。 我将解释 LMS 主题和插件之间的区别&#xff0c;以便你了解要…
阅读更多...
Unity中实现ScrollRect 滚动定位到视口内

Unity中实现ScrollRect 滚动定位到视口内

Demo链接: https://download.csdn.net/download/qq_41973169/89439428https://download.csdn.net/download/qq_41973169/89439428 一、前言 Unity版本:2020.1.x 如果需要资源请联系我我会分享给你 因为本人也要存储一下Demo所以上传到这里了但是又不能设置不需要积分 在Un…
阅读更多...
车载网络安全指南 软件层面开发阶段（八）

车载网络安全指南 软件层面开发阶段（八）

返回总目录->返回总目录<- 目录 前言 一、软件层面产品开发启动 二、确定网络安全需求 三、软件架构设计 四、软件层面漏洞分析 五、软件单元设计和实现 六、软件实现的分析与评估 七、软件单元测试 八、软件集成和测试 九、网络安全验证 十、细化网络安全评估…
阅读更多...
发布自己的c#包到nuget

发布自己的c#包到nuget

1)创建自己的nuget账号 NuGet Gallery | Home 2)在Rider中-->项目邮件-->properties 注意&#xff1a;必须勾选生成nuget包 3)编译后&#xff0c;将生成一个包 4)点击上传包 5)将之前的nuget包拖拽过来&#xff0c;点击上传即可&#xff0c;如果有不对的比如&#xf…
阅读更多...
C++ 43 之 自增运算符的重载

C++ 43 之 自增运算符的重载

#include <iostream> #include <string> using namespace std;class MyInt{friend ostream& operator<< (ostream& cout , MyInt& int1); public:MyInt(){this->m_num 0;}// 前置自增&#xff1a; 成员函数实现运算符的重载 返回的是 引用&a…
阅读更多...
Android 蓝牙配对Settings应用里面的简要流程记录

Android 蓝牙配对Settings应用里面的简要流程记录

Android 蓝牙配对Settings应用里面的简要流程记录 文章目录 Android 蓝牙配对Settings应用里面的简要流程记录一、前言二、Settings蓝牙配对的关键代码1、接收蓝牙请求的地方 AndroidManifest.xml2、BluetoothPairingRequest3、BluetoothPairingService4、BluetoothPairingDial…
阅读更多...
石头、剪子、布小游戏图形化

石头、剪子、布小游戏图形化

石头、剪子、布小游戏图形化 也是之前编写了一个石头、剪子、布的小游戏&#xff0c;总感觉界面不够友好&#xff0c;AI时代到来&#xff0c;一切都无所不能&#xff0c;而且编程效率大大提高了。所以用AI大模型进行程序代码重构&#xff0c;再稍加修改&#xff0c;效果还不错…
阅读更多...
LLM proj - 审稿大模型

LLM proj - 审稿大模型

常用数据处理 主要是四种方式&#xff1a;正则表达式、AC自动机、困惑度过滤低质文本、最小哈希算法实现文本去重 1. 正则表达式&#xff0c;去做一些模式匹配 ex&#xff1a; # 论文的评审内容有时会存在大量列举reference&#xff08;参考文献&#xff09;的情况 # 这些r…
阅读更多...
KKT基础知识

KKT基础知识

KKT条件定义 KKT条件(Karush–Kuhn–Tucker conditions)是最优化&#xff08;特别是非线性规划&#xff09;领域最重要的成果之一&#xff0c;是判断某点是极值点的必要条件。 最优化问题 要选择一组参数&#xff08;变量&#xff09;&#xff0c;在满足一定的限制条件&…
阅读更多...
Unity动态添加聊天文本

Unity动态添加聊天文本

1.创建一个滚动视图 2.调整滚动视图的位置并删掉这个 3.创建一个输入框和一个按钮 这里插一句一定要给content添加这个组件并设置单元格大小 4创建一个脚本并编写下面代码 using System.Collections; using System.Collections.Generic; using TMPro; using Unity.VisualScrip…
阅读更多...
⭐Unity 控制任意UI的渐隐渐显

⭐Unity 控制任意UI的渐隐渐显

使用脚本之前先给要控制的UI加上CanvasGroup组件 解释: 这个脚本使用协程来逐渐改变CanvasGroup的alpha值&#xff0c;从而实现渐隐和渐显的效果。 Mathf.Lerp函数用于在指定的时间内平滑地从当前透明度过渡到目标透明度。 通过调用FadeIn和FadeOut方法&#xff0c;你可以在任…
阅读更多...
人工智能在风险管理中的创新之路及案例分析

人工智能在风险管理中的创新之路及案例分析

随着科技的日新月异&#xff0c;人工智能&#xff08;AI&#xff09;技术已广泛应用于各个领域&#xff0c;特别是在风险管理方面&#xff0c;其展现出的巨大潜力和实际应用价值引人瞩目。本文将结合具体案例&#xff0c;深入探讨AI在风险管理中的创新应用及其带来的行业变革。…
阅读更多...
FANUC机器人SRVO-454和SRVO-455故障报警处理总结

FANUC机器人SRVO-454和SRVO-455故障报警处理总结

FANUC机器人SRVO-454和SRVO-455故障报警处理总结 公司内的一台FANUC机器人（型号：M-900iB；控制柜型号：R-30iB）正常运转过程中突然报警： SRVO-455 CPU看门狗（G:1 A:2），按Reset键无法消除该报警； 查看SRVO-455故障报警的具体内容，如下图所示： 由于现场没有备用的伺服放…
阅读更多...
ubuntu 22.04下利用webmin 搭建一个Wordpress 网站（2）

ubuntu 22.04下利用webmin 搭建一个Wordpress 网站（2）

上次我们讲到第二部分&#xff0c;今天我们继续这一个话题 第三部分&#xff1a;利用webmin创建一个wordpress网站 1、在 Webmin 内安裝Apache 未使用的模块> Apache Webserver > 现在安装 会出现如下图所示的有关软件 刷新模快后 检查开机时要自动启动Apache 测…
阅读更多...
Midjourney提示词终极指南(完整版)

Midjourney提示词终极指南(完整版)

在这篇博客中&#xff0c;我们深入研究了使用提示的艺术&#xff0c;以利用Midjourney的AI功能的力量。我们将探索各种技术&#xff0c;以创建个性化和迷人的图像&#xff0c;将你的创意想法转变为令人惊叹的视觉杰作。 1. 了解提示词 提示是简短的文字描述或关键词&#xff…
阅读更多...
JavaScript——初识：JavaScript的组成、输入和输出语句... | JavaScript基础：变量，数据类型转换

JavaScript——初识：JavaScript的组成、输入和输出语句... | JavaScript基础：变量，数据类型转换

目录 初识JavaScript JavaScript的组成 输入和输出语句 ECMAScript 6保留关键字 变量的命名规范 注意事项 JavaScript基础 变量的数据类型 数据类型分类 数据类型转换 转换为字符串型 转换为数字型 转换为布尔型 例题 初识JavaScript JavaScript的组成 Java…
阅读更多...
SpringAI快速上手

SpringAI快速上手

一、导入依赖 镜像&#xff08;导入maven依赖&#xff09; <repositories><repository><id>spring-snapshots</id><name>Spring Snapshots</name><url>https://repo.spring.io/snapshot</url><releases><enabled>…
阅读更多...
RPG游戏完整指南

RPG游戏完整指南

环境&#xff1a;unity2021urp 本教程教大家如何使用Unity创建一个RPG游戏&#xff0c;玩家可以在城镇场景中进行导航并寻找战斗&#xff0c;并在战斗中遇到不同类型的敌人。玩家可以向敌人施加不同的动作&#xff0c;如&#xff1a;常规攻击和撤离。这会是一个十分有趣的体验。…
阅读更多...
大疆Pocket2手持记录仪格式化恢复方法

大疆Pocket2手持记录仪格式化恢复方法

大疆Pocket系列是手持类产品&#xff0c;此类产品处理过不少&#xff0c;今天来看一个Pocket2误格式化之后的恢复方法。 故障存储:256G存储卡 /文件系统&#xff1a;exFAT 故障现象: 客户描述其经常对存储进行格式化&#xff0c;一般重新拍就会格式化一次&#xff0c;需要恢…
阅读更多...
Linux下的串口通信

Linux下的串口通信

串口通信 基础知识&#xff1a; 什么是串口&#xff1f; 串口全称串行通信接口&#xff0c;是一种常用于电子设备之间通信的异步&#xff0c;全双工接口&#xff0c;典型的串口通信只需要 3 根线&#xff0c;分别是地线 (GND)&#xff0c;发送线(TX)&#xff0c;接收线(RX)。如…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023