第一章:SpringBoot基础入门

这篇具有很好参考价值的文章主要介绍了第一章:SpringBoot基础入门。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

第一章:SpringBoot基础入门

1.1:Spring与SpinrBoot

  1. Spring能做什么

    • Spring的能力
      第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

    • Spring的生态

      网址:https://spring.io/projects/spring-boot

      覆盖了:Web开发、数据访问、安全控制、分布式、消息服务、移动开发、批处理等。

    • Spring5重大升级

      1. 响应式编程
        第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

      2. 内部源码设计

        基于Java8的一些新特性。

  2. 为什么用SpringBoot

    Spring Boot makes it easy to create stand-alone, production-grade Spring based Applications that you can "just run"。能快速创建出生产级别的Spring应用。

    • SpringBoot的优点

      1. Create stand-alone Spring applications:创建独立的Spring应用。
      2. Embed Tomcat, Jetty or Undertow directly (no need to deploy WAR files):内嵌Web服务器。
      3. Provide opinionated 'starter' dependencies to simplify your build configuration:自动starter依赖,简单构建配置
      4. Automatically configure Spring and 3rd party libraries whenever possible:自动配置Spring以及第三方功能。
      5. Provide production-ready features such as metrics, health checks, and externalized configuration:提供生产级别的监控、健康检查以及外部化配置。
      6. Absolutely no code generation and no requirement for XML configuration:无代码生成、无需编写XML

      SpringBoot是整合Spring技术栈的一站式框架,SpringBoot是简化Spring技术栈的快速开发脚手架。

    • SpringBoot的缺点

      1. 迭代快,需要时刻关注变化。
      2. 封装太深,内部原理复杂,不容易精通。
  3. 时代背景

    • 微服务

      James Lewis and Martin Fowler (2014) 提出微服务完整概念。https://martinfowler.com/microservices/

      ​ 微服务是一种架构风格。一个应用拆分为一组小型服务。每个服务运行在自己的进程内,也就是可独立部署和升级。服务之间使用轻量级HTTP交互。服务围绕业务功能拆,可以由全自动部署机制独立部署,去中心化,服务自治。服务可以使用不同的语言、不同的存储技术。

    • 分布式
      第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

      1. 分布式的困难

        远程调用、服务发现、负载均衡、服务容错、配置管理、服务监控、链路追踪、日志管理、任务调度。

      2. 分布式的解决

        SpringBoot + SpringCloud
        第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

  4. 如何学习SpringBoot

    • 官网文档架构
      第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java
      第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

      查看版本新特性:https://github.com/spring-projects/spring-boot/wiki#release-notes
      第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

1.2:SpringBoot2入门

需求:浏览器发送/hello请求,响应Hello, Spring Boot 2

  1. 创建maven工程

    IDEA创建一个新的工程boot_helloworld_01

  2. 引入依赖

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.3.4.RELEASE</version>
    </parent>
    
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    
  3. 创建主程序

    package com.wang;
    
    // 主程序类。@SpringBootApplication:这是一个SpringBoot应用
    @SpringBootApplication
    public class MainApplication {
        public static void main(String[] args) {
            SpringApplication.run(MainApplication.class, args);
        }
    }
    
  4. 编写业务

    package com.wang.controller;
    
    @RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public String handle01() {
            return "Hello, Spring Boot 2!";
        }
    }
    
  5. 测试

    直接运行mian方法,浏览器访问http://localhost:8080/hello
    第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

  6. 修改配置

    resources文件夹下创建application.properties文件

    server.port=8888
    

    修改了上面配置,重新启动项目,http://localhost:8080/hello访问成功。

  7. 简化部署

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    

    重新打成一个jar包在cmd窗口下也能运行。
    第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java
    第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

1.3:了解自动配置原理

  1. SpringBoot特点

    • 依赖管理

      1. 父项目做依赖管理

        几乎声明了所有开发中常用的依赖的版本号,自动版本仲裁机制。

        <!-- 依赖管理,自己工程引入的依赖 -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.3.4.RELEASE</version>
        </parent>
        
        <!-- 它的父项目 -->
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>2.3.4.RELEASE</version>
        </parent>
        
      2. 开发导入starter场景启动器

        • 见到很多spring-boot-starter-**就是某种场景。

        • 只要引入starter,这个场景的所有常规需要的依赖我们都自动引入。

        • SpringBoot所有支持的场景:

          https://docs.spring.io/spring-boot/docs/current/reference/html/using.html#using.build-systems.starters

        • 见到*-spring-boot-starter:第三方为我们提供的简化开发的场景启动器。

        • 所有场景启动器最底层的依赖

          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter</artifactId>
              <version>2.3.4.RELEASE</version>
              <scope>compile</scope>
          </dependency>
          
      3. 无需关注版本号,自动版本仲裁

        • 引入依赖默认都可以不写版本。
        • 引入非版本仲裁的jar,要写版本号。
      4. 可以修改默认版本

        查看spring-boot-dependencies里面规定当前依赖的版本用的key

        <!-- 举例:修改mysql的版本依赖 -->
        <properties>
            <mysql.version>5.1.43</mysql.version>
        </properties>
        
    • 自动配置

      1. 自动配好Tomcat

        • 引入Tomcat依赖

          <dependency>
              <groupId>org.springframework.boot</groupId>
              <artifactId>spring-boot-starter-tomcat</artifactId>
              <version>2.3.4.RELEASE</version>
              <scope>compile</scope>
          </dependency>
          
        • 配置Tomcat

      2. 自动配置好SpringMVC

        • 引入SpringMVC全套组件。
        • 自动配好SpringmVC常用组件(功能)。
      3. 自动配好Web常见功能

        • SpringBoot帮我们配置好了所有Web开发的场景。
      4. 默认的包结构

        • 主程序所在包及其下面的所有子包里面的组件都会被默认扫描出来。

        • 无序以前的包扫描配置。

        • 想要改变扫描路径:@SpringBootApplication(scanBasePackages = "com")或者@ComponentScan("com.wang")指定扫描路径

          @SpringBootApplication(scanBasePackages = "com.wang")
          // 等同于
          @SpringBootConfiguration
          @EnableAutoConfiguration
          @ComponentScan("com.wang")
          
      5. 各种配置拥有默认值

        • 默认配置最终都是映射到某个类上。
        • 配置文件的值最终会绑定在每个类上,这个类会在容器中创建对象。
      6. 按需加载所有自动配置项

        • 非常多的starter
        • 引入了哪些场景这个场景的自动配置才会开启。
        • SpringBoot所有的自动配置功能都在spring-boot-autoconfigure包里面。
  2. 容器功能

    • 添加组件

      先创建两个实体类:UserPet

      package com.wang.bean;
      
      // 用户
      public class User {
          private String name;
          private Integer age;
          private Pet pet;
      
          // 省略空参、全参构造、get/set方法、toString方法
      }
      
      package com.wang.bean;
      
      // 宠物
      public class Pet {
          private String name;
      
          // 省略空参、全参构造、get/set方法、toString方法
      }
      
      1. @Configuration

        Full模式与Lite模式:

        • 配置类组件之间无依赖关系用Lite模式加速容器启动过程,减少判断。
        • 配置类组件之间有依赖关系,方法会被调用得到之前单实例组件,用Full模式。
        // Configuration使用示例
        package com.wang.config;
        
        // 配置类里面使用@Bean标注在方法给容器注册组件,默认也是单实例的。
        // 配置类本身也是组件
        // proxyBeanMethods =  false:代理bean的方法
        	// Full(proxyBeanMethods =  true): 【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
        	// Lite(proxyBeanMethods =  false): 【每个@Bean方法被调用多少次返回的组件都是新创建的】
        	// 组件依赖必须使用Full模式默认。其他默认是否Lite模式
        
        // 告诉SpringBoot这一个配置类 == 配置文件
        @Configuration(proxyBeanMethods =  false)
        public class MyConfig {
        
            // 给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值,就是组件在容器中的实例
            @Bean
            public User user01() {
                User zhangsan =  new User("zhangsan", 18);
                // User组件依赖了Pet组件
                zhangsan.setPet(tomcatPet());
                return zhangsan;
            }
        
            @Bean("tom")
            public Pet tomcatPet() {
                return new Pet("tomcat");
            }
        }
        
        // Configuration测试代码
        package com.wang;
        
        @SpringBootApplication
        public class MainApplication {
        
            public static void main(String[] args) {
                // 1. 返回我们IOC容器
                ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
                
                // 2. 查看容器里面的组件
                String[] names = run.getBeanDefinitionNames();
                for (String name: names) {
                    System.out.println(name);
                }
        
                // 3.从容器中获取组件
                Pet tom01 = run.getBean("tom", Pet.class);
                Pet tom02 = run.getBean("tom", Pet.class);
                System.out.println("组件:" + (tom01 == tom02));
                MyConfig bean = run.getBean(MyConfig.class);
                System.out.println(bean);
                
                // 4. 组件是否单例
                User user1 = bean.user01();
                User user2 = bean.user01();
                System.out.println(user1 == user2);
        
                User user01 = run.getBean("user01", User.class);
                Pet tom = run.getBean("tom", Pet.class);
                System.out.println("用户的宠物: " + (user01.getPet() == tom));
            }
        }
        
      2. @Import()

        @Import({User.class, DBHelper.class})给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名。

      3. @Conditional

        条件装配:满足Conditional指定的条件,则进行组件注入。

        // 条件转配示例
        package com.wang.config;
        
        @Configuration
        // 容器中存在tom组件时,才给类中的bean进行组件注入
        @ConditionalOnBean(name = "tom")
        public class MyConfig {
        
            @Bean
            public User user01() {
                User zhangsan =  new User("zhangsan", 18);
                zhangsan.setPet(tomcatPet());
                return zhangsan;
            }
        
            @Bean("tom22")
            public Pet tomcatPet() {
                return new Pet("tomcat");
            }
        }
        
        // 测试条件装配
        package com.wang;
        
        @SpringBootApplication()
        public class MainApplication {
            public static void main(String[] args) {
                ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        
                boolean tom = run.containsBean("tom");
                System.out.println("容器中Tom组件:" + tom);
                boolean user01 = run.containsBean("user01");
                System.out.println("容器中user01组件:" + user01);
                boolean tom22 = run.containsBean("tom22");
                System.out.println("容器中tom22组件:" + tom22);
            }
        }
        
    • 原生配置文件引入

      1. @ImportResource

        <!--创建beans.xml配置文件-->
        <bean id="haha" class="com.wang.bean.User">
            <property name="name" value="zhangsan"></property>
            <property name="age" value="18"></property>
        </bean>
        
        <bean id="hehe" class="com.wang.bean.Pet">
            <property name="name" value="tomcat"></property>
        </bean>
        
        package com.wang.config;
        
        // 添加@ImportResource注解
        @ImportResource("classpath:beans.xml")
        public class MyConfig { .... }
        
        // 测试IOC容器是否存在haha和hehe组件
        package com.wang;
        
        @SpringBootApplication
        public class MainApplication {
            public static void main(String[] args) {
                ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
        
                boolean haha = run.containsBean("haha");
                System.out.println("haha: :" + haha);
                boolean hehe = run.containsBean("hehe");
                System.out.println("hehe::" + hehe);
            }
        }
        
    • 配置绑定

      如何使用Java读取到properties文件中的内容,并且把它封装到JavaBean中,以供随时使用:

      # application.properties文件中 
      mycar.brand=BYD
      mycar.price=100000
      
      1. @ConfigurationProperties

        package com.wang.bean;
        
        // 只有在容器中的组件,才会拥有SpringBoot提供的强大功能
        @Component
        @ConfigurationProperties(prefix = "mycar")
        public class Car {
            private String brand;
            private Integer price;
        	
            // 省略get/set方法、toString方法
        }
        
      2. @EnableConfigurationProperties+@ConfigurationProperties

        package com.wang.bean;
        
        @ConfigurationProperties(prefix = "mycar")
        public class Car { ..... }
        
        package com.wang.config;
        
        @Configuration
        // 1.开启Car配置绑定功能
        // 2.把这个Car这个组件自动注册到容器中
        @EnableConfigurationProperties(Car.class)
        public class MyConfig { ... }
        
  3. 自动配置原理入门

    • 引导加载类自动配置

      @SpringBootConfiguration
      @EnableAutoConfiguration
      @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
      		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
      public @interface SpringBootApplication { ... }
      
      1. @SpringBootConfiguration

        // 代表当前是一个配置类
        @Configuration
        public @interface SpringBootConfiguration {}
        
      2. @ComponentScan

        // 指定扫描那些注解
        @Repeatable(ComponentScans.class)
        public @interface ComponentScan { .... }
        
      3. @EnableAutoConfiguration

        @AutoConfigurationPackage
        @Import(AutoConfigurationImportSelector.class)
        public @interface EnableAutoConfiguration { ... }
        
        • @AutoConfigurationPackage

          // 利用Registrar给容器中导入一系列组件
          // 将指定的一个包下的所有组件导入进来,MainApplication主程序所在的包下
          @Import(AutoConfigurationPackages.Registrar.class)
          public @interface AutoConfigurationPackage { .... }
          
          package org.springframework.boot.autoconfigure;
          
          public abstract class AutoConfigurationPackages {
          
              ......
              
          	/**
          	 * {@link ImportBeanDefinitionRegistrar} to store the base package from the importing
          	 * configuration.
          	 */
          	static class Registrar implements ImportBeanDefinitionRegistrar, DeterminableImports {
          
          @Override
          public void registerBeanDefinitions(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
          	register(registry, new PackageImports(metadata).getPackageNames().toArray(new String[0]));
           }
                  
          		@Override
          		public Set<Object> determineImports(AnnotationMetadata metadata) {
          			return Collections.singleton(new PackageImports(metadata));
          		}
          	}
              
              .....
          }
          

          第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

        • @Import(AutoConfigurationImportSelector.class)

          // 1.利用getAutoConfigurationEntry(annotationMetadata)给容器中批量导入一些组件
          // 2.调用List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes)
          // 获取到所有需要导入到容器中的配置类
          package org.springframework.boot.autoconfigure;
          
          public class AutoConfigurationImportSelector implements  DeferredImportSelector,
          	BeanClassLoaderAware, ResourceLoaderAware, BeanFactoryAware, EnvironmentAware, Ordered {
                  
                  ......
                  
              @Override
          	public String[] selectImports(AnnotationMetadata annotationMetadata) {
          		if (!isEnabled(annotationMetadata)) {
          			return NO_IMPORTS;
          		}
               AutoConfigurationEntry autoConfigurationEntry = getAutoConfigurationEntry(annotationMetadata);
          		return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());
          	}
                  
          protected AutoConfigurationEntry getAutoConfigurationEntry(AnnotationMetadata annotationMetadata) {
          		if (!isEnabled(annotationMetadata)) {
          			return EMPTY_ENTRY;
          		}
          		AnnotationAttributes attributes = getAttributes(annotationMetadata);
          		List<String> configurations = getCandidateConfigurations(annotationMetadata, attributes);
          		configurations = removeDuplicates(configurations);
          		Set<String> exclusions = getExclusions(annotationMetadata, attributes);
          		checkExcludedClasses(configurations, exclusions);
          		configurations.removeAll(exclusions);
          		configurations = getConfigurationClassFilter().filter(configurations);
          		fireAutoConfigurationImportEvents(configurations, exclusions);
          		return new AutoConfigurationEntry(configurations, exclusions);
          	}
                       
                  .......   
          }
          

          第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

          // 接上面的类
          protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, 
                                                            AnnotationAttributes attributes) {
          		List<String> configurations = 
                      SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
          		Assert.notEmpty(configurations, 
                                  "No auto configuration classes found in META-INF/spring.factories. If you "
          				+ "are using a custom packaging, make sure that file is correct.");
          		return configurations;
          }
          
          
          
          
          // 3.利用工厂加载Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader)
          // 得到所有的组件
          
          // 4.从META-INF/spring.factories位置来加载一个文件。
          // 默认扫描我们当前系统里面所有META-INF/spring.factories位置的文件。
          // spring-boot-autoconfigure-2.3.4.RELEASE.jar包里面有META-INF/spring.factories
          package org.springframework.core.io.support;
          
          public final class SpringFactoriesLoader {
              
              ....
              
              // 此方法的返回值
              public static List<String> loadFactoryNames(Class<?> factoryType, 
                                                          @Nullable ClassLoader classLoader) {
          		String factoryTypeName = factoryType.getName();
          	return loadSpringFactories(classLoader).getOrDefault(factoryTypeName, Collections.emptyList());
          	}
              
              private static Map<String, List<String>> loadSpringFactories(@Nullable ClassLoader classLoader) {
          		MultiValueMap<String, String> result = cache.get(classLoader);
          		if (result != null) {
          			return result;
          		}
          
          		try {
          			Enumeration<URL> urls = (classLoader != null ?
          					classLoader.getResources(FACTORIES_RESOURCE_LOCATION) :
          					ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
          			result = new LinkedMultiValueMap<>();
          			while (urls.hasMoreElements()) {
          				URL url = urls.nextElement();
          				UrlResource resource = new UrlResource(url);
          				Properties properties = PropertiesLoaderUtils.loadProperties(resource);
          				for (Map.Entry<?, ?> entry : properties.entrySet()) {
          					String factoryTypeName = ((String) entry.getKey()).trim();
          					for (String factoryImplementationName : StringUtils.commaDelimitedListToStringArray((String) entry.getValue())) {
          						result.add(factoryTypeName, factoryImplementationName.trim());
          					}
          				}
          			}
          			cache.put(classLoader, result);
          			return result;
          		}
          		catch (IOException ex) {
          			throw new IllegalArgumentException("Unable to load factories from location [" +
          					FACTORIES_RESOURCE_LOCATION + "]", ex);
          		}
          	}
                  
              ....
              
          }
          

          第一章:SpringBoot基础入门,SpringBoot,spring boot,后端,java

    • 按需开启自动配置项

      # 文件里面写死了springBoot启动就要给容器加载的所有配置类
      ....
      # Auto Configure
      org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
      org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
      org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
      org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
      org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
      ....
      
      # 虽然我们127个场景的所有自动配置启动的时候默认全部加载。XxxAutoConfiguration
      # 按照条件装配规则(@Conditional),最终会按需配置。
      
    • 总结

      // 随便点开spring-boot-autoconfigure-2.3.4.RELEASE.jar包下XxxAutoConfiguration文件看是否配置了此组件
      @Configuration(proxyBeanMethods = false)
      @EnableConfigurationProperties(ServerProperties.class)
      @ConditionalOnWebApplication(type = ConditionalOnWebApplication.Type.SERVLET)
      @ConditionalOnClass(CharacterEncodingFilter.class)
      @ConditionalOnProperty(prefix = "server.servlet.encoding", value = "enabled", matchIfMissing = true)
      public class HttpEncodingAutoConfiguration { .... }
      
      1. SpringBoot先加载所有的自动配置类XxxAutoConfiguration
      2. 每个自动配置类按照条件进行生效,默认都会绑定配置文件指定的值。XxxProperties里面拿。XxxProperties和配置文件进行了绑定。
      3. 生效的配置类就会给容器中装配很多组件。
      4. 只要容器中有这些组件,就相当于这些功能就有了。
      5. 定制化配置。
        • 用户直接自己@Bean替换底层的组件。
        • 用户去看这个组件是获取的配置文件什么值就去修改。

      XxxAutoConfiguration ——> 加载组件 ——> XxxProperties里面拿值 ——> application.properties修改配置

    • 最佳实践文章来源地址https://www.toymoban.com/news/detail-659779.html

      1. 引入场景依赖
      2. 查看自动配置了哪些(选做):配置文件中debug=true开启自动配置报告。【Negative(不生效)、Positive(生效)】
      3. 是否需要修改:参照文档修改配置项
      4. 自动加入或者替换组件:@Bean、@Component....
      5. 自定义器XxxCustomizer

到了这里,关于第一章:SpringBoot基础入门的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • SpringBoot + Vue前后端分离项目实战 || 二:Spring Boot后端与数据库连接

    系列文章: SpringBoot + Vue前后端分离项目实战 || 一:Vue前端设计 SpringBoot + Vue前后端分离项目实战 || 二:Spring Boot后端与数据库连接 SpringBoot + Vue前后端分离项目实战 || 三:Spring Boot后端与Vue前端连接 SpringBoot + Vue前后端分离项目实战 || 四:用户管理功能实现 SpringBoot + Vue前后

    2024年02月11日
    浏览(59)
  • 【SpringBoot】| Spring Boot 概述和入门程序剖析

    目录 一:Spring Boot 入门 1. Spring能做什么? 2. SpringBoot特点 3. 如何学习SpringBoot 4. 创建Spring Boot项目 Maven的配置 入门案例: SpringBoot中几个重要的注解 5. 了解自动配置原理 依赖管理 自动配置 6. SpringBoot核心配置文件 多环境测试 自定义配置 7. SpringBoot中使用JSP(了解) 8. S

    2024年02月06日
    浏览(52)
  • 【Spring Security详解】第一章 | 概述

    从本系列开始,博主将带来大家深入学习Spring Security。博主对该框架的看法是不但要会使用,还有能够理解其源码,要知其然,还要知其所以然。 相信朋友们阅读完博主本系列全部文章之后,定会理解Spring Security,让我们从入门、到理解、最终吊打面试官! PS:博主早在8月中

    2023年04月08日
    浏览(37)
  • 第一章 MATLAB入门

    MATLAB(矩阵实验室的简称)是一种专业的计算机程序,用于工程科学的矩阵数学运算。但 在以后的几年内,它逐渐发展为一种极其灵活的计算体系,用于解决各种重要的技术问题。 Matlab程序执行MATLAB语言,并提供了一个极其广泛的预定义函数库,这样就使得技术工作 变得简

    2024年02月05日
    浏览(41)
  • ElasticSearch第一章(入门介绍)

    ElasticSearch(弹性搜索),简称ES。 ES是一个分布式,RESTFul风格的搜索和数据分析引擎 ,能够解决不断涌现出的各种用例。作为 Elastic Stack(Elastic技术栈简称ELK) 的核心,Elasticsearch 会集中存储您的数据,让您飞快完成搜索,微调相关性,进行强大的分析,并轻松缩放规模。 我

    2024年02月22日
    浏览(40)
  • 第一章 小程序入门

    小程序的基本结构 小程序的页面组成部分 JSON 配置文件的作用 app.json 配置文件 project.config.json 配置文件 sitemap.json 配置文件 页面 .json 配置文件 什么是 wxml wxml 和 html 的区别 什么是 wxss wxss 和 css 的区别 通信模型 小程序的启动过程 页面渲染过程 button 按钮的基本使用 img 组件

    2024年02月08日
    浏览(60)
  • 第一章 快速入门

    TypeScript是JavaScript的超集。 它对JS进行了扩展,向JS中引入了类型的概念,并添加了许多新的特性。 TS代码需要通过编译器编译为JS,然后再交由JS解析器执行。 TS完全兼容JS,换言之,任何的JS代码都可以直接当成JS使用。 相较于JS而言,TS拥有了静态类型,更加严格的语法,更

    2024年02月01日
    浏览(35)
  • ChatGPT入门到高级【第一章】

    第一章:Chatgpt的起源和发展 1.1 人工智能和Chatbot的概念 1.2 Chatbot的历史发展 1.3 机器学习技术在Chatbot中的应用 1.4 Chatgpt的诞生和发展 第二章:Chatgpt的技术原理 2.1 自然语言处理技术 2.2 深度学习技术 2.3 Transformer模型 2.4 GPT模型 第三章:Chatgpt的应用场景 3.1 智能客服 3.2 智能问

    2024年02月04日
    浏览(31)
  • 第一章 Web自动化入门

    1、概念 由机器设备代替人工自动完成指定目标的过程 2、优点 减少人工劳动力 提高工作效率 产品规格统一标准 规格化(批量生产) 概念:让程序代替人工去验证系统功能的过程 解决-回归测试(重点) 解决-压力测试 解决-兼容性测试(浏览器、分辨率、操作系统) 提高测

    2024年02月07日
    浏览(45)
  • Linux——(第一章)Linux的入门

    VMwear workstations下载及安装 Ubuntu server 18.04安装 VScode下载与安装 使用VS Code连接远程服务器 MobaXterm的下载安装及远程连接 Filezila的下载、安装与使用(向服务器传输文件) 目录 1.概述 2.Linux和Windows的区别 3.VM的安装与使用         Linux内核最早由芬兰人林纳斯·托瓦兹(Linus

    2024年02月10日
    浏览(29)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包