Java.慈祥
Java.慈祥

SpringBoot2基础入门 学习(一)

SpringBoot2 基础入门

SpringBoot 简介

JavaEE开发的一站式解决方案！
简化Spring应用开发的一个框架，整个Spring技术栈的一个大整合；

SpringBoot时代背景

微服务

2014 ，martin fowler马丁·福勒
提出的：微服务架构风格 常听的：分布式微服务

优点：
一个应用拆分为一组小型服务
每一个服务： 运行在自己的进程内，也就是可独立部署和升级，通过HTTP的方式进行互通;
• 服务围绕业务功能拆分
• 可以由全自动部署机制独立部署
• 去中心化，服务自治。服务可以使用不同的语言、不同的存储技术; 只要实现功能即可~
在这里插入图片描述
上图：微服务分布式架构，每一个点表示一个功能, 使用时只需要调用需要的功能模块组合即可！

缺点：

  • 运维要求高： 更多的服务意味着要投入更多的运维。
  • 分布式固有的复杂性：
    使用微服务构建的是分布式系统。对于一个分布式系统，系统容错、网络延迟、
    分布式事务等都会带来巨大的问题。
  • 接口调整成本高：
    微服务之间通过接口进行通信。
    如果修改某一个微服务的API，可能所有用到这个接口的微服务都需要进行调整。
    远程调用、服务发现、负载均衡、服务容错、配置管理、服务监控、链路追踪、日志管理、任务调度……

说到微服务架构，不得不提的就是 单体应用

单体应用

一个归档包（可以是JAR、WAR、EAR或其它归档格式）包含所有功能的应用程序，通常称为单体应用。
在这里插入图片描述
优点

  • 便于共享： 单个归档文件包含所有功能，便于在团队之间以及不同的部署阶段之间共享。
  • 易于测试：
    单体应用一旦部署，所有的服务或特性就都可以使用了，这简化了测试过程。
    因为没有额外的依赖，每项测试都可以在部署完成后立刻开始。
  • 易于部署： 只需将单个归档文件复制到单个目录下。

缺点

  • 复杂性高：
    由于是单个归档文件，所以一个文件 等于 整个项目，文件包含的模块非常多，导致模块的边界模糊。
    依赖关系不清晰、代码的质量参差不齐，混乱的堆在一起，使得整个项目非常复杂。
    以致每次修改代码，都非常小心，可能添加一个简单的功能，或者修改一个Bug都会带来隐藏的缺陷。
  • 技术债务：
    随着时间的推移、需求的变更和技术人员的更替，会逐渐形成应用程序的技术债务，并且越积越多。
  • 扩展能力受限：
    单体应用只能作为一个整体进行扩展，无法根据业务模块的需要进行伸缩。
    (为了提高项目性能可以, 将一个项目复制多份部署多台服务器~)
  • 阻碍技术创新：
    对于单体应用来说，技术是在开发之前经过慎重评估后选定的，
    每个团队成员都必须使用相同的开发语言、持久化存储及消息系统。

SpringBoot2入门

环境约束

Java8 或以上 学习
Maven3.3 或以上 学习
本人使用的编辑器是: Idea2020 或其它编辑器，Spring官方的推荐的 STS

maven设置

settings.xml 文件修改配置~ Maven——conf目录下：

  
  <mirrors>
      <mirror>
        <id>nexus-aliyunid>
        <mirrorOf>centralmirrorOf>
        <name>Nexus aliyunname>
        <url>http://maven.aliyun.com/nexus/content/groups/publicurl>
      mirror>
  mirrors>
 
  <profiles>
         <profile>
              <id>jdk-1.8id>
              <activation>
                <activeByDefault>trueactiveByDefault>
                <jdk>1.8jdk>
              activation>
              <properties>
                <maven.compiler.source>1.8maven.compiler.source>
                <maven.compiler.target>1.8maven.compiler.target>
                <maven.compiler.compilerVersion>1.8maven.compiler.compilerVersion>
              properties>
         profile>
  profiles>

什么是SpringBoot

Springboot是用于简化原始Spring的复杂
快速创建出生产级别的Spring应用，也是Spring技术栈的一站式框架。
本质上还是Spring，只不过将以往需要配置的信息封装到底层，使开发者更加快捷的搭建好环境。
因此被称为Spring的脚手架:

  • 脚手架指的是两种技术之一：
    第一种是与某些MVC 框架中的数据库访问相关的代码生成技术;
    第二种是由各种工具支持的项目生成技术。

SpringBoot的优点

内嵌Web服务器
创建独立的Spring应用
无代码生成，无需编写XML
自动starter以来，简化构建配置
自动配置Spring以及第三方功能
提供生产级别的监控、健康检查以及外部化配置

SpringBoot缺点

人称版本帝，迭代快，需要时刻关注变化
封装太深，内部原理复杂，不容易精通

正片开始

好了，从现在开始我们可以迅速创建一个SpringBoot应用，
可以通过IDEA的快捷配置方式
同时也可以使用Maven直接配置，在这里只演示第二种方式。

HelloWorld！！

需求：浏览发送/hello请求，响应 Hello, Spring Boot 2
SpringBoot2基础入门 学习(一)_第1张图片

1.创建maven工程

引入依赖：
pom.xml

	
	<parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.6.RELEASEversion>
    parent>
    
	
    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-webartifactId>
        dependency>
    dependencies>

2.创建主程序

SpringBoot程序需要一个入口: 负责启动开启应用程序

  • 主程序类一般声明在最外层包下，默认扫描所在包下的所有类注解 方便初始化应用！
  • 这里提到很多新的注解，之前常用的MVC 注解依然可以使用, 根据喜好使用 可以多学习了解~
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;

@SpringBootApplication  //标注主程序类,这是一个Springboot应用! 
//@SpringBootApplication(scanBasePackages = "指定扫描包下注解~") 	//默认扫描该类的包及子包~
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);
    }
}

3.创建Controller控制器：

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

//作用:该类是一个Controller控制器 且 下所有方法的返回值为一个JSON
//相当于是一个:@Controller 和 @ResponseBody 注解的集合,内部SpringBoot 自定义了完善的属性配置,当然也可以通过配置修改覆盖...
@RestController
public class HelloController {
     
    //相当于: 以前SpringMVC的 @RequestMapping get方式请求~
    //@RequestMapping(value = "/show" ,method = RequestMethod.GET)
    @GetMapping(value = "/show")    //@GetMapping用于处理请求方法的GET类型，@PostMapping用于处理请求方法的POST类型等。
    public String Hello(){
     
        return "Hello Wrod!!";
    }
}

4. 启动主程序类：

每错直接启动即可：SpringBoot中有自带的集成运行环境容器;
可以清除的看到 Tomcat initialized with port(s): 8080 (http)
SpringBoot2基础入门 学习(一)_第2张图片
SpringBoot2基础入门 学习(一)_第3张图片

或打包控制台——部署运行（简化部署）：

使用Maven 打包程序：
pom.xml 文件中加入

   
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.bootgroupId>
                <artifactId>spring-boot-maven-pluginartifactId>
                <version>2.2.6.RELEASEversion>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackagegoal>
                        goals>
                    execution>
                executions>
            plugin>
        plugins>
    build>

SpringBoot2基础入门 学习(一)_第4张图片

ok, 到这基本体现到 SpringBoot 应用程序的强大！
无须服务器！单体项目~ 强大注解生态资源自带集成~！！

SpringBoot特点

以下说明全部来源于 大佬！！ 本人借鉴学习！

依赖管理

SpringBoot　对依赖管理非常强大！
在Spring Boot入门程序中，项目pom.xml文件有两个核心依赖~
分别是spring-boot-starter-parent和spring-boot-starter-web 关于这两个依赖的相关介绍具体如下。

spring-boot-starter-parent

举例说明：pom.xml

<parent>
        <groupId>org.springframework.bootgroupId>
        <artifactId>spring-boot-starter-parentartifactId>
        <version>2.1.6.RELEASEversion>
parent>
  • 上述代码中，将spring-boot-starter-parent依赖作为Spring Boot项目的统一父项目依赖管理
    并将项目版本号统一为2.1.6.RELEASE，该版本号根据实际开发需求是可以修改的。
  • 使用Ctrl+鼠标左键进入并查看spring-boot-starter-parent底层源文件：
  • 发现spring-boot-starter-parent的底层有一个父依赖spring-boot-dependencies，核心代码具体如下。
<parent>
  <groupId>org.springframework.bootgroupId>
  <artifactId>spring-boot-dependenciesartifactId>
  <version>2.1.3.RELEASEversion>
  <relativePath>../../spring-boot-dependenciesrelativePath>
parent>
...

继续查看spring-boot-dependencies底层源文件，核心代码具体如下。

<properties>
  <activemq.version>5.15.8activemq.version>
  ...
  <solr.version>7.4.0solr.version>
  
  <spring.version>5.1.5.RELEASEspring.version>
  <spring-amqp.version>2.1.4.RELEASEspring-amqp.version>
  <spring-batch.version>4.1.1.RELEASEspring-batch.version>
  <spring-cloud-connectors.version>2.0.4.RELEASEspring-cloud-connectors.version>
  <spring-data-releasetrain.version>Lovelace-SR5spring-data-releasetrain.version>
  <spring-framework.version>${spring.version}spring-framework.version>
  <spring-security.version>5.1.4.RELEASEspring-security.version>
  <spring-session-bom.version>Bean-SR3spring-session-bom.version>
  <spring-ws.version>3.0.6.RELEASEspring-ws.version>
  <sqlite-jdbc.version>3.25.2sqlite-jdbc.version>
  <statsd-client.version>3.1.0statsd-client.version>
  <sun-mail.version>${javax-mail.version}sun-mail.version>
  <thymeleaf.version>3.0.11.RELEASEthymeleaf.version>
  <tomcat.version>9.0.16tomcat.version>				
  <unboundid-ldapsdk.version>4.0.9unboundid-ldapsdk.version>
  <undertow.version>2.0.17.Finalundertow.version>
  <versions-maven-plugin.version>2.7versions-maven-plugin.version>
  <webjars-hal-browser.version>3325375webjars-hal-browser.version>
  <webjars-locator-core.version>0.35webjars-locator-core.version>
properties>
  • 从spring-boot-dependencies底层源文件可以看出
    该文件通过< properties >标签对一些常用技术框架的依赖文件进行了统一版本号管理，
    例如 activemq、spring、tomcat等，都有与Spring Boot 2.1.3版本相匹配的版本，
    这也是pom.xml引入依赖文件不需要标注依赖文件版本号的原因。
  • 需要说明的是，如果pom.xml引入的依赖文件不是 spring-boot-starter-parent管理的，
  • 那么在pom.xml引入依赖文件时，需要使用 < version > 标签指定依赖文件的版本号。

开发中见到很多：见到很多 spring-boot-starter-*

spring-boot-starter-web 依赖

spring-boot-starter-parent父依赖启动器的主要作用是进行版本统一管理:
那么项目运行依赖的JAR包是从何而来？又是怎样管理的呢？
下面，查看项目pom.xml文件中的spring-boot-starter-web依赖。

查看spring-boot-starter-web依赖文件源码，核心代码具体如下。

<dependencies>
  <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starterartifactId>
    <version>2.1.3.RELEASEversion>
    <scope>compilescope>
  dependency>
  <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-jsonartifactId>
    <version>2.1.3.RELEASEversion>
    <scope>compilescope>
  dependency>
  <dependency>
    <groupId>org.springframework.bootgroupId>
    <artifactId>spring-boot-starter-tomcatartifactId>
    <version>2.1.3.RELEASEversion>
    <scope>compilescope>
  dependency>
  <dependency>
    <groupId>org.hibernate.validatorgroupId>
    <artifactId>hibernate-validatorartifactId>
    <version>6.0.14.Finalversion>
    <scope>compilescope>
  dependency>
  
dependencies>

spring-boot-starter-web依赖启动器的主要作用：

  • 是提供Web开发场景所需的底层所有依赖文件，
    它对Web开发场景所需的依赖文件进行了统一管理。
  • 正是如此，在pom.xml中引入spring-boot-starter-web依赖启动器时，就可以实现Web场景开发
    不需要额外导入Tomcat服务器以及其他Web依赖文件等。
    当然，这些引入的依赖文件的版本号还是由spring-boot-starter-parent父依赖进行的统一管理。

Spring Boot除了提供有上述介绍的Web依赖启动器外，还提供了其他许多开发场景的相关依赖，我们可以打开Spring Boot官方文档，搜索“Starters”关键字查询场景依赖启动器，具体如下图所示。
SpringBoot2基础入门 学习(一)_第5张图片

@SpringBootApplication注解 + 自动装配原理

@SpringBootApplication注解表示Spring Boot启动类。

  • Spring Boot应用的启动入口是@SpringBootApplication注解标注类中的main()方法
    @SpringBootApplication能够扫描Spring组件并自动配置Spring Boot
  • 查看@SpringBootApplication注解源码 :
  • 按住: Ctrl + @SpringBootApplication
@Target({
     ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
//以上一些Java的注解无伤大雅！
@SpringBootConfiguration     // 标明该类为配置类
@EnableAutoConfiguration     // 启动自动配置功能
@ComponentScan(              // 包扫描器
    excludeFilters = {
     @Filter(
    type = FilterType.CUSTOM,
    classes = {
     TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {
     AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication {
     
...
}

@SpringBootApplication注解是一个组合注解：
包含@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan三个核心注解

@SpringBootConfiguration注解

@SpringBootConfiguration注解表示类为： Spring Boot配置类


@Target({
     ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Configuration
public @interface SpringBootConfiguration {
     
}

@SpringBootConfiguration注解内部有一个核心注解@Configuration

  • Spring框架提供的注解: 表示当前类为一个配置类（XML配置文件的注解表现形式）
  • 并可以被组件扫描器扫描。
    由此可见，@SpringBootConfiguration注解的作用与@Configuration注解相同
  • 都是标识一个可以被组件扫描器扫描的配置类，
    只不过@SpringBootConfiguration是被Spring Boot进行了重新封装命名而已。

@EnableAutoConfiguration注解

@EnableAutoConfiguration注解表示开启自动配置功能
该注解是Spring Boot框架最重要的注解，也是实现自动化配置的注解。


@Target({
     ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@AutoConfigurationPackage                             // 自动配置包
@Import({
     AutoConfigurationImportSelector.class}) // 自动配置类扫描导入
public @interface EnableAutoConfiguration {
     
    String ENABLED_OVERRIDE_PROPERTY = "spring.boot.enableautoconfiguration";
    Class<?>[] exclude() default {
     };
    String[] excludeName() default {
     };
}

@EnableAutoConfiguration注解也是一个组合注解，
它主要包括有@AutoConfigurationPackage和@Import两个核心注解。
自己查看以下注解 Ctrl +

  • @AutoConfigurationPackage：
    @AutoConfigurationPackage注解的功能是由@Import注解实现的，
    作用是向容器导入注册的所有组件，导入的组件由Registrar决定
  • @Import({AutoConfigurationImportSelector.class})：　
    使用了这个注解，相当于 Java 中的 import 关键字，可以导入 Spring 的 bean 到 IOC 容器中。

@AutoConfigurationPackage：类
自动配置包？指定了默认的包规则

@Import(AutoConfigurationPackages.Registrar.class)  //给容器中导入一个组件
public @interface AutoConfigurationPackage {
     }
 
//利用Registrar给容器中导入一系列组件
//将指定的一个包下的所有组件导入进来？MainApplication 所在包下。

查看AutoConfigurationImportSelector类的getAutoConfigurationEntry()方法，核心代码具体如下。
Ctrl + F Idea查看文本


protected AutoConfigurationImportSelector.AutoConfigurationEntry
        getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata,
 AnnotationMetadata annotationMetadata) {
     
  if (!this.isEnabled(annotationMetadata)) {
     
    return EMPTY_ENTRY;
  } else {
     
    AnnotationAttributes attributes = this.getAttributes(annotationMetadata);
         // 获取所有Spring Boot提供的后续自动配置类XxxAutoConfiguration
    List<String> configurations = 
this.getCandidateConfigurations(annotationMetadata, attributes);
    configurations = this.removeDuplicates(configurations);
    Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);
    this.checkExcludedClasses(configurations, exclusions);
    configurations.removeAll(exclusions);
         // 筛选并过滤出当前应用环境下需要的自动配置类XxxAutoConfiguration
    configurations = this.filter(configurations, autoConfigurationMetadata);
    this.fireAutoConfigurationImportEvents(configurations, exclusions);
    return new AutoConfigurationImportSelector.AutoConfigurationEntry(
configurations, exclusions);
  }
}

在上述展示的getAutoConfigurationEntry()方法，

  • 其主要作用是筛选出当前项目环境需要启动的自动配置类XxxAutoConfiguration
  • 从而实现当前项目运行所需的自动配置环境。

另外，在上述核心方法中加粗显示了2个重要的业务处理方法，具体说明如下。

  • this.getCandidateConfigurations(annotationMetadata, attributes)方法：
    该方法的主要作用是从Spring Boot提供的自动配置依赖的META-INF/spring.factories文件中
    获取所有候选自动配置类XxxAutoConfiguration（2.1.3版本提供有121个自动配置类）；
  • this.filter(configurations, autoConfigurationMetadata)方法：
    该方法的作用是对所有候选的自动配置类进行筛选，根据项目pom.xml文件中加入的依赖文件筛选出
    最终符合当前项目运行环境对应的自动配置类（筛选完成后可能只有25个）。

SpringBoot 提供的自动配置类
SpringBoot在启动的时候从自动配置类路径下的META-INF/spring.factorles中获取
EnableAutoConfiguration指定的值，并将这些值作为自动配置类导入到容器中，自动配置类就生效。
SpringBoot2基础入门 学习(一)_第6张图片
在项目中加入了Web环境依赖启动器

  • 对应的WebMvcAutoConfiguration自动配置类就会生效，打开该自动配置类会发现
    在该配置类中通过全注解配置类的方式对Spring MVC运行所需环境进行了默认配置，
    包括：默认前缀、默认后缀、视图解析器、MVC校验器等。
  • 而这些自动配置类的本质是传统Spring MVC框架中对应的XML配置文件
  • 只不过在Spring Boot中以自动配置类的形式进行了预先配置。
  • 因此，在Spring Boot项目中加入相关依赖启动器后，基本上不需要任何配置就可以运行程序，
  • 当然，我们也可以对这些自动配置类中默认的配置进行更改。

@ComponentScan注解

@ComponentScan注解是一个组件包扫描器，
其主要作用是扫描指定包及其子包下所有注解类文件作为Spring容器的组件使用。

okok, 就到这里了, 后面在深入研究~ 好累需要反复斟酌~

Spring常用注解使用分析：

@Configuration

相当于 Spring配置文件中的< beans>标签
告诉SpringBoot这是一个配置类，配置类本身也是组件 等于以前Spring项目的Sring配置文件.xml；
配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的 Full
另外注意，被@configuration标注的类本身，也会作为一个bean注入到容器中的。

Full模式与Lite模式

proxyBeanMethods：代理bean的方法

  • Full(proxyBeanMethods = true)
    保证每个@Bean方法被调用多少次返回的组件都是单实例的
  • Lite(proxyBeanMethods = false)
    每个@Bean方法被调用多少次返回的组件都是新创建的
  • 组件依赖必须使用Full模式默认。

@Bean

给容器中添加组件。
以方法名作为组件的 id。返回类型就是组件类型。返回的值，就是组件在容器中的实例；

Demo测试1

SpringBoot2基础入门 学习(一)_第7张图片

以上项目加一个包 com.wsm.entity
加一个 测试实体类 User.Java

public class User {
     
    private int id=0;
    private String name="默认";
    //get/set
    //toString()....

加一个包 com.wsm.config
加入一个 配置类
ConfigXX.Java

//配置类学习
@Configuration
public class ConfigXX {
     
    //Bean
    //就相当于以前的: 
    @Bean           //以方法名作为组件的id  返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public String str(){
     
        return "字符";
    }
    @Bean("myUser") //指定组件id名,将该对象存储到spring的上下文中 （环境中）
    public User user() {
     
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
    @Bean("tom")
    public User userTom(){
     
        User user = new User();
        user.setId(1);
        user.setName("tom");
        return user;
    }
}

主程序类SpringBootRun.Java

@SpringBootApplication  //标注主程序类,这是一个Springboot应用!
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        //查看容器里面所有的组件,Bean
        String[] names = run.getBeanDefinitionNames();
        System.out.println("-----------所有的组件Bean----------");
        for (String name : names) {
     
            //因为,有很多是默认的所以会有很多~
            System.out.println(name);
        }

        //从容器中根据id获取指定组件
        String str = (String)run.getBean("str");   //方法返回Object类型——》强制转换
        System.out.println(str);
        //查询Spring上下文存在该元素
        boolean isok = run.containsBean("str");
        System.out.println(isok);
        
        User myUser = (User)run.getBean("myUser");
        System.out.println(myUser);

        User tom1 = (User)run.getBean("tom");
        User tom2 = (User)run.getBean("tom");
        System.out.println(tom1==tom2);     //比较结果:true 结论@Configuration默认模式是Full 单例
    	//被@Configuration注解的类同时也被注入
        ConfigXX cfx = (ConfigXX)run.getBean(ConfigXX.class);
        System.out.println(cfx.user()==cfx.user());     //结果为true 调用new 的方法同样是true;
	}
}

SpringBoot2基础入门 学习(一)_第8张图片

@ImportResource 引入原生配置

以上的配置类 的使用, 刚开始学习时候有一点的不舒服~
SpringBoot 本质上是Spring的管理, 当然还是支持Spring的核心 IOC
也还可以使用以前的Spring配置文件来管理项目！

  • 使用 @ImportResource 引入原生配置

Demo测试2

SpringBoot2基础入门 学习(一)_第9张图片

Maven工程 resource资源目录下添加一个Sping配置文件：
beanConf.xml


<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <bean id="w" class="com.wsm.entity.User">bean>
beans>

主程序

@SpringBootApplication                  //标注主程序类,这是一个Springboot应用!
@ImportResource("classpath:beanConf.xml")  //classpath表示就是资源目录下; 这里不多解释了...
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        User user = (User) run.getBean("w");
        System.out.println(user);
    }
}

SpringBoot2基础入门 学习(一)_第10张图片

@import

声明在类上
这个注解在老版本SpringBoot1中，将他放在configuration 配置类上的时候

  • 只能完成引入别的configuration类的功能。类似于容器xml配置文件的import标签。

但是在新版本中，可以引入任何类，不一定是configuration类。

  • 这样就变得非常灵活。这里 的引入就是注入的意思。将该类注入到容器中，
  • 即使该类没有被注解@service, @controller,@repository, @component等所标注。

语法：
@import({注入类.class,多个类.class})
主程序类

@SpringBootApplication                  //标注主程序类,这是一个Springboot应用!
@Import({
     User.class})
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        User u = run.getBean(User.class);
        System.out.println(u);
    }
}

注意：
使用前要确保该类型确实不存在任何一个Spring管理Bean
不然：在这里插入图片描述

@componentscan

这个注解主要是标注需要扫描哪些包路径。
该路径下标注了@service, @controller,@repository, @component的类，
都将被注入到容器中。除了这四个标签，包路径下标注了@configuration类，也会被注入到容器中。
@import 升级版本！

@Conditional 条件装配

声明在 配置类上！@Configuration
只有满足Conditional指定的条件，则进行 配置类组件注入！！！
实现动态配置 SpringBoot 的组件, 对一些组件进行判断则生成~

  • SpringBoot 底层配置了这么多的类不可能每次都全部加载！！
  • 底层就是采用该注解进行配置，是否存在使用依赖则执行底层类的注入大致原理有兴趣在研究~
  • 该注解的类型有很多…

SpringBoot2基础入门 学习(一)_第11张图片

Demo3测试3

修改ConfigXX.Java

@Configuration
@ConditionalOnBean(name = "abc")    //检查上下文中是否存在abc，如果存在,才执行下面的所有的创建操作      
//@ConditionalOnMissingBean(name = "abc") 
//检查上下文中是否存在abc，如果没有存在,执行下面的所有的创建操作
public class ConfigXX {
     
    //Bean
    //就相当于以前的: 
    @Bean           //以方法名作为组件的id  返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public String str(){
     
        return "字符";
    }
    @Bean("tom")
    public User userTom(){
     
        User user = new User();
        user.setId(1);
        user.setName("tom");
        return user;
    }
    @Bean("myUser") //指定组件id名,将该对象存储到spring的上下文中 （环境中）
    public User user() {
     
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

分别执行主程序：

@SpringBootApplication
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        //查看容器里面所有的组件,Bean
        String[] names = run.getBeanDefinitionNames();
        System.out.println("-----------所有的组件Bean----------");
        for (String name : names) {
     
            //因为,有很多是默认的所以会有很多~
            System.out.println(name);
        }
    }
}

@ConditionalOnBean(name = “abc”) 存在执行

SpringBoot2基础入门 学习(一)_第12张图片

@ConditionalOnMissingBean(name = “tom”) 不存在执行

SpringBoot2基础入门 学习(一)_第13张图片

@ConfigurationProperties 配置绑定

在编写项目代码时，我们要求更灵活的配置，更好的模块化整合。

  • 在 Spring Boot 项目中，为满足以上要求，
  • 我们将大量的参数配置在 application.properties或 application.yml 文件中，
  • 通过 @ConfigurationProperties 注解，我们可以方便的获取这些参数值

application.properties和application.yml文件的区别
一般上来说，当我们创建一个SpringBoot项目时
，IDE会默认帮我们创建一个application.properties配置文件。有些朋友习惯把.properties文件改成.yml文件。

  • .properties文件，通过.来连接，通过=来赋值，结构上，没有分层的感觉，但比较直接。
  • .yml文件，通过：来分层，结构上，有比较明显的层次感，最后key赋值的：后需要留一个空格。
  • 执行顺序:
    如果工程中同时存在application.properties文件和 application.yml文件
    yml文件会先加载，而后加载的properties文件会覆盖yml文件。
    所以建议工程中，只使用其中一种类型的文件即可。

@Component

声明在 @ConfigurationProperties 类上
@Component （把普通pojo实例化到spring容器中，相当于配置文件中的 ） 泛指各种组件，
就是说当我们的类不属于各种归类的时候 （不属于@Controller、@Services等的时候）
我们就可以使用@Component来标注这个类。

@EnableConfigurationProperties

@EnableConfigurationProperties注解的作用是： 使用 @ConfigurationProperties 注解的类生效。

  • 如果一个配置类只配置@ConfigurationProperties注解，而没有使用@Component
    那么在IOC容器中是获取不到properties 配置文件转化的bean。

  • 说白了 @EnableConfigurationProperties
    相当于把使用 @ConfigurationProperties 的类进行了一次注入。

  • @EnableConfigurationProperties 和 @Component 二者取其一

Demo测试.properties

com.wsm.entity包下加入 Student.Java

//配置类注解，被自动扫描发现
//@Component
@ConfigurationProperties(prefix = "stu")                     //指明前缀
@PropertySource("classpath:application.properties")        //指明配置源文件位置
public class Student {
     
    private int id;
    private String name;
    //get/set/toString()....
}

resources目录下加入application.properties

# 修改SpringBoot的端口 默认8080
server.port=9090     
#根据@ConfigurationProperties 声明类的前缀进行 .属性=值 注入;
stu.id=10001
stu.name=admin

#.properties文件
#键值注入 字符串不需要引号..

主程序：

@SpringBootApplication
@EnableConfigurationProperties({
     Student.class})
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        Student stu = run.getBean(Student.class);
        System.out.println(stu);
    }
}

在这里插入图片描述

Demo测试.yml

com.wsm.entity包下加入 Person.java

@ConfigurationProperties(prefix = "person")
public class Person {
     
    private String userName;
    private Boolean boss;
    private Date birth;
    private Integer age;
    private User user;
    private String[] interests;
    private List<String> animal;
    private Map<String, Object> score;
    private Set<Double> salarys;
    //get/set/toString()
}

yml编写规范 学习

大小写敏感
使用缩进表示层级关系
缩进时不允许使用Tab键，只允许使用空格。
缩进的空格数目不重要，只要相同层级的元素左侧对齐即可
YAML 支持的数据结构有三种

  • 对象：键值对的集合，又称为映射（mapping）/ 哈希（hashes） / 字典（dictionary）
  • 数组：一组按次序排列的值，又称为序列（sequence） / 列表（list）
  • 纯量（scalars）：单个的、不可再分的值

一组键值对，使用冒号结构表示
键：值 :冒号后面必须跟着空格！！ 一定要注意错误了不易检查！！

resources目录下加入application.yml

person:
  userName: 张三
  boss: true
  birth: 2020/01/01 15:20:30
  age: 20
  user:                             #对象User类型
    id: 1001
    name: 张三
  interests: ['test01','test02']    #字符串数组
  animal:                           #字符串集合
  - cat                                 #字符串值
  - dog
  score:                            #Map类型 String,Object类型
    english:                          #Map元素键1
      first: 100                        #Map键1的值：又是一个Map类型
      last: 20
    math: [10,20,30,40]               #Map元素键2：也是一个Map类型
    chinese: {one: 50,two: 60,three: 70}
  salarys: [4555.5,4666.5,4777.5]

主程序：

@SpringBootApplication
@EnableConfigurationProperties({
     Student.class, Person.class})
public class SpringBootRun {
     
    public static void main(String[] args) {
     
        //用来执行开启SpringBoot程序;                                 参数当前主程序类.class  args
        ConfigurableApplicationContext run = SpringApplication.run(SpringBootRun.class,args);

        Person person = run.getBean(Person.class);
        System.out.println(person);
    }
}

在这里插入图片描述

自动配置原理入门自定义

自动配置类的作用，配置注入功能组件自动完成。
根据上面的 SpringBoot的特定得知SpringBoot的底层就是大量的 自动配置类 SpringBoot2 128个

详情查看 @EnableAutoConfiguration注解

自定义 自动配置

SpringBoot2基础入门 学习(一)_第14张图片
pom.xml



<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>
    <groupId>org.examplegroupId>
    <artifactId>SpringBoot128artifactId>
    <version>1.0-SNAPSHOTversion>

    <dependencies>
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-autoconfigureartifactId>
            <version>2.1.6.RELEASEversion>
        dependency>
    dependencies>
project>

Spring Boot优化了很多配置的方式方法，
让我们少去了很多配置的环节。但又给了我们自定义配置的选择权。

在SpringBoot中会有许多的自带自动装配，
通常在启动时加载，如何实现自己定义的自动装配？我们需要三个 关键类:

属性读取类

该类的作用是读取hello开头的属性配置文件
读取值后会存入到容器中。默认值是Spring Boot
HelloProperties.Java

@Component
@ConfigurationProperties(prefix = "hello")		//使用配置绑定 前缀hello
public class HelloProperties {
     
    private String msg = "SpringBoot";			
	//默认值 SpringBoot,如果引入自动配置的项目可以通过 .properties .yml 文件中,进行更改！						
    public String getMsg() {
     
        return msg;
    }
    public void setMsg(String msg) {
     
        this.msg = msg;
    }
}

核心事件类

该类主要处理 配置类要执行的主要功能！！
我们定义该类来将定义的msg加上hello前缀。
Hello.Java

public class Hello {
     
    private  String msg;
    public String say(){
     	
        return  "hello"+getMsg();		//打印输出Hello + msg
    }
    public String getMsg() {
     
        return msg;
    }
    public void setMsg(String msg) {
     
        this.msg = msg;
    }
}

整合类

整合类是最重要的类，它关系着前两个类的运作。
HelloAutoConfigration.Java

@Configuration   //这是一个配置类
@ConditionalOnClass(Hello.class)    //是否存在 Hello的类,没有不执行类中操作...
@EnableConfigurationProperties(HelloProperties.class)   //开启使用 @ConfigurationProperties 注解的类生效。
@ConditionalOnProperty(prefix = "hello", value = "enabled", matchIfMissing = true)
//prefix 数组，获取property名称的前缀，可有可无
//name 数组，property完整名称或部分名称，与prefix组合使用组成完整属性名称，与value不可同时存在
//value 数组，获取property完整名称或部分名称，与prefix组合使用成完整属性名称，与name不可同时存在
//havingValue 比较获取的属性值与havingValue给定的值是否相同，相同才加载配置类
//matchIfMissing 缺少property时是否加载，如果为true，没有该property属性也会正常加载，反之报错。
//是否存在 hello 属性则执行下面操作..
public class HelloAutoConfigration {
     

    @Autowired
    private HelloProperties helloProperties;
    @Bean
    @ConditionalOnMissingBean
    public Hello createHello() {
     
        Hello hello = new Hello();
        hello.setMsg(helloProperties.getMsg());
        return hello;
    }
}

使用

将maven文件打包后加载入仓库
给要使用的类添加pom配置

在控制器输出
SpringBoot2基础入门 学习(一)_第15张图片

Controller

HelloController.Java

import com.wsm.Hello;           //引入依赖的类型;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController  //@Controller @ResponseBody
public class HelloController {
     

    @Autowired
    private Hello hello;        //注入

    @GetMapping(value = "/showMsg")
    public String shoMsg(){
     
        return  hello.say();
    }
}

引入自定义配置依赖

pom.xml


<dependency>
    <groupId>org.examplegroupId>
    <artifactId>SpringBoot128artifactId>
    <version>1.0-SNAPSHOTversion>
dependency>

你可能感兴趣的:(SpringBoot,分布式,微服务,spring,boot,java,spring)

  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • LocalDateTime 转 String igotyback java开发语言
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
  • Linux下QT开发的动态库界面弹出操作（SDL2） 13jjyao QT类qt开发语言sdl2linux
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
  • 腾讯云技术深度探索：构建高效云原生微服务架构 我的运维人生 云原生架构腾讯云运维开发技术共享
    腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team 若博豆 java算法华为javascript
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
  • GitHub上克隆项目 bigbig猩猩 github
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业javascripthtmlcss旅游风景
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动 二挡起步 web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
  • node.js学习 小猿L node.jsnode.js学习vim
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
  • 01-Git初识 Meereen Gitgit
    01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞 文章永久免费只为良心 oracle数据库
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
  • Java 重写(Override)与重载(Overload) 叨唧唧的
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
  • 简单了解 JVM 记得开心一点啊 jvm
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven Energet!c 开发语言
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
  • Java企业面试题3 马龙强_ java
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
  • JVM、JRE和 JDK：理解Java开发的三大核心组件 Y雨何时停T Javajava
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
  • python语法——三目运算符 HappyRocking pythonpython三目运算符
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
  • spring如何整合druid连接池？ 惜.己 springspringjunit数据库javaidea后端xml
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • Kafka是如何保证数据的安全性、可靠性和分区的 喜欢猪猪 kafka分布式
    Kafka作为一个高性能、可扩展的分布式流处理平台，通过多种机制来确保数据的安全性、可靠性和分区的有效管理。以下是关于Kafka如何保证数据安全性、可靠性和分区的详细解析：一、数据安全性SSL/TLS加密：Kafka支持SSL/TLS协议，通过配置SSL证书和密钥来加密数据传输，确保数据在传输过程中不会被窃取或篡改。这一机制有效防止了中间人攻击，保护了数据的安全性。SASL认证：Kafka支持多种
  • Java爬虫框架（一）--架构设计 狼图腾-狼之传说 java框架java任务html解析器存储电子商务
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
  • Java：爬虫框架 dingcho Javajava爬虫
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
  • python怎么将png转为tif_png转tif weixin_39977276
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
  • SpringCloudAlibaba—Sentinel(限流) 菜鸟爪哇
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
  • springboot+vue项目实战一-创建SpringBoot简单项目 苹果酱0567 面试题汇总与解析springboot后端java中间件开发语言
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy） 跳房子的前端 前端面试javascript开发语言ecmascript
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
  • 微信开发者验证接口开发 362217990 微信 开发者 token 验证
    微信开发者接口验证。 Token，自己随便定义，与微信填写一致就可以了。 根据微信接入指南描述 http://mp.weixin.qq.com/wiki/17/2d4265491f12608cd170a95559800f2d.html 第一步：填写服务器配置 第二步：验证服务器地址的有效性 第三步：依据接口文档实现业务逻辑 这里主要讲第二步验证服务器有效性。 建一个
  • 一个小编程题-类似约瑟夫环问题 BrokenDreams 编程
            今天群友出了一题：         一个数列,把第一个元素删除,然后把第二个元素放到数列的最后,依次操作下去,直到把数列中所有的数都删除,要求依次打印出这个过程中删除的数。      &
  • linux复习笔记之bash shell (5) 关于减号-的作用 eksliang linux关于减号“-”的含义linux关于减号“-”的用途linux关于“-”的含义linux关于减号的含义
        转载请出自出处： http://eksliang.iteye.com/blog/2105677        管道命令在bash的连续处理程序中是相当重要的，尤其在使用到前一个命令的studout（标准输出）作为这次的stdin（标准输入）时，就显得太重要了，某些命令需要用到文件名，例如上篇文档的的切割命令（split）、还有
  • Unix(3) 18289753290 unix ksh
    1)若该变量需要在其他子进程执行，则可用"$变量名称"或${变量}累加内容 什么是子进程？在我目前这个shell情况下，去打开一个新的shell，新的那个shell就是子进程。一般状态下，父进程的自定义变量是无法在子进程内使用的，但通过export将变量变成环境变量后就能够在子进程里面应用了。 2)条件判断： &&代表and  ||代表or&nbs
  • 关于ListView中性能优化中图片加载问题 酷的飞上天空 ListView
    ListView的性能优化网上很多信息，但是涉及到异步加载图片问题就会出现问题。 具体参看上篇文章http://314858770.iteye.com/admin/blogs/1217594   如果每次都重新inflate一个新的View出来肯定会造成性能损失严重，可能会出现listview滚动是很卡的情况，还会出现内存溢出。 现在想出一个方法就是每次都添加一个标识，然后设置图
  • 德国总理默多克：给国人的一堂“震撼教育”课 永夜-极光 教育
    http://bbs.voc.com.cn/topic-2443617-1-1.html德国总理默多克：给国人的一堂“震撼教育”课　 安吉拉—默克尔，一位经历过社会主义的东德人，她利用自己的博客，发表一番来华前的谈话，该说的话，都在上面说了，全世界想看想传播——去看看默克尔总理的博客吧！ 　　德国总理默克尔以她的低调、朴素、谦和、平易近人等品格给国人留下了深刻印象。她以实际行动为中国人上了一堂
  • 关于Java继承的一个小问题。。。 随便小屋 java
    今天看Java 编程思想的时候遇见一个问题，运行的结果和自己想想的完全不一样。先把代码贴出来！ //CanFight接口 interface Canfight { void fight(); } //ActionCharacter类 class ActionCharacter { public void fight() { System.out.pr
  • 23种基本的设计模式 aijuans 设计模式
    Abstract Factory：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。 　　Adapter：将一个类的接口转换成客户希望的另外一个接口。A d a p t e r模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 　　Bridge：将抽象部分与它的实现部分分离，使它们都可以独立地变化。 　　Builder：将一个复杂对象的构建与它的表示分离，使得同
  • 《周鸿祎自述：我的互联网方法论》读书笔记 aoyouzi 读书笔记
    从用户的角度来看,能解决问题的产品才是好产品,能方便/快速地解决问题的产品,就是一流产品.   商业模式不是赚钱模式 一款产品免费获得海量用户后,它的边际成本趋于0,然后再通过广告或者增值服务的方式赚钱,实际上就是创造了新的价值链.   商业模式的基础是用户,木有用户,任何商业模式都是浮云.商业模式的核心是产品,本质是通过产品为用户创造价值. 商业模式还包括寻找需求
  • JavaScript动态改变样式访问技术 百合不是茶 JavaScriptstyle属性ClassName属性
      一:style属性 格式:  HTML元素.style.样式属性="值";   创建菜单:在html标签中创建 或者 在head标签中用数组创建   <html> <head> <title>style改变样式</title> </head> &l
  • jQuery的deferred对象详解 bijian1013 jquerydeferred对象
            jQuery的开发速度很快，几乎每半年一个大版本，每两个月一个小版本。         每个版本都会引入一些新功能，从jQuery 1.5.0版本开始引入的一个新功能----deferred对象。    &nb
  • 淘宝开放平台TOP Bill_chen C++c物流C#
    淘宝网开放平台首页：http://open.taobao.com/ 淘宝开放平台是淘宝TOP团队的产品，TOP即TaoBao Open Platform， 是淘宝合作伙伴开发、发布、交易其服务的平台。 支撑TOP的三条主线为：    1.开放数据和业务流程     * 以API数据形式开放商品、交易、物流等业务；  &
  • 【大型网站架构一】大型网站架构概述 bit1129 网站架构
    大型互联网特点 面对海量用户、海量数据 大型互联网架构的关键指标 高并发 高性能 高可用 高可扩展性 线性伸缩性 安全性 大型互联网技术要点   前端优化 CDN缓存 反向代理 KV缓存 消息系统 分布式存储 NoSQL数据库 搜索 监控 安全 想到的问题： 1.对于订单系统这种事务型系统，如
  • eclipse插件hibernate tools安装 白糖_ Hibernate
    eclipse helios(3.6)版 1.启动eclipse 2.选择 Help > Install New Software...> 3.添加如下地址： http://download.jboss.org/jbosstools/updates/stable/helios/ 4.选择性安装：hibernate tools在All Jboss tool
  • Jquery easyui Form表单提交注意事项 bozch jquery easyui
    jquery easyui对表单的提交进行了封装，提交的方式采用的是ajax的方式，在开发的时候应该注意的事项如下：         1、在定义form标签的时候，要将method属性设置成post或者get，特别是进行大字段的文本信息提交的时候，要将method设置成post方式提交，否则页面会抛出跨域访问等异常。所以这个要
  • Trie tree(字典树)的Java实现及其应用-统计以某字符串为前缀的单词的数量 bylijinnan java实现
    import java.util.LinkedList; public class CaseInsensitiveTrie { /** 字典树的Java实现。实现了插入、查询以及深度优先遍历。 Trie tree's java implementation.(Insert,Search,DFS) Problem Description Igna
  • html css 鼠标形状样式汇总 chenbowen00 htmlcss
    css鼠标手型cursor中hand与pointer  Example：CSS鼠标手型效果 <a href="#" style="cursor:hand">CSS鼠标手型效果</a><br/>  Example：CSS鼠标手型效果 <a href="#" style=&qu
  • [IT与投资]IT投资的几个原则 comsci it
          无论是想在电商,软件,硬件还是互联网领域投资,都需要大量资金,虽然各个国家政府在媒体上都给予大家承诺,既要让市场的流动性宽松,又要保持经济的高速增长....但是,事实上,整个市场和社会对于真正的资金投入是非常渴望的,也就是说,表面上看起来,市场很活跃,但是投入的资金并不是很充足的......    
  • oracle with语句详解 daizj oraclewithwith as
    oracle with语句详解 转 在oracle中，select 查询语句，可以使用with,就是一个子查询，oracle 会把子查询的结果放到临时表中，可以反复使用 例子:注意，这是sql语句，不是pl/sql语句， 可以直接放到jdbc执行的 ----------------------------------------------------------------
  • hbase的简单操作 deng520159 数据库hbase
    近期公司用hbase来存储日志,然后再来分析 ,把hbase开发经常要用的命令找了出来. 用ssh登陆安装hbase那台linux后 用hbase shell进行hbase命令控制台! 表的管理 1）查看有哪些表 hbase(main)> list 2）创建表   # 语法：create <table>, {NAME => <family&g
  • C语言scanf继续学习、算术运算符学习和逻辑运算符 dcj3sjt126com c
    /* 2013年3月11日20:37:32 地点：北京潘家园 功能：完成用户格式化输入多个值 目的：学习scanf函数的使用 */ # include <stdio.h> int main(void) { int i, j, k; printf("please input three number:\n"); //提示用
  • 2015越来越好 dcj3sjt126com 歌曲
    越来越好 房子大了电话小了 感觉越来越好 假期多了收入高了 工作越来越好 商品精了价格活了 心情越来越好 天更蓝了水更清了 环境越来越好 活得有奔头人会步步高 想做到你要努力去做到 幸福的笑容天天挂眉梢 越来越好 婆媳和了家庭暖了 生活越来越好 孩子高了懂事多了 学习越来越好 朋友多了心相通了 大家越来越好 道路宽了心气顺了 日子越来越好 活的有精神人就不显
  • java.sql.SQLException: Value '0000-00-00' can not be represented as java.sql.Tim feiteyizu mysql
    数据表中有记录的time字段（属性为timestamp）其值为：“0000-00-00 00:00:00” 程序使用select 语句从中取数据时出现以下异常： java.sql.SQLException:Value '0000-00-00' can not be represented as java.sql.Date   java.sql.SQLException: Valu
  • Ehcache（07）——Ehcache对并发的支持 234390216 并发ehcache锁ReadLockWriteLock
    Ehcache对并发的支持          在高并发的情况下，使用Ehcache缓存时，由于并发的读与写，我们读的数据有可能是错误的，我们写的数据也有可能意外的被覆盖。所幸的是Ehcache为我们提供了针对于缓存元素Key的Read（读）、Write（写）锁。当一个线程获取了某一Key的Read锁之后，其它线程获取针对于同
  • mysql中blob,text字段的合成索引 jackyrong mysql
      在mysql中，原来有一个叫合成索引的，可以提高blob,text字段的效率性能， 但只能用在精确查询，核心是增加一个列，然后可以用md5进行散列，用散列值查找 则速度快 比如： create table abc(id varchar(10),context blog,hash_value varchar(40)); insert into abc(1,rep
  • 逻辑运算与移位运算 latty 位运算逻辑运算
    源码：正数的补码与原码相同例+7 源码：00000111 补码 ：00000111 （用8位二进制表示一个数） 负数的补码： 符号位为1，其余位为该数绝对值的原码按位取反；然后整个数加1。   -7 源码： 10000111 ，其绝对值为00000111  取反加一：11111001 为-7补码 已知一个数的补码，求原码的操作分两种情况：
  • 利用XSD 验证XML文件 newerdragon javaxmlxsd
    XSD文件 （XML Schema 语言也称作 XML Schema 定义（XML Schema Definition，XSD）。 具体使用方法和定义请参看： http://www.w3school.com.cn/schema/index.asp java自jdk1.5以上新增了SchemaFactory类 可以实现对XSD验证的支持，使用起来也很方便。 以下代码可用在J
  • 搭建 CentOS 6 服务器(12) - Samba rensanning centos
    （1）安装 # yum -y install samba Installed: samba.i686 0:3.6.9-169.el6_5 # pdbedit -a rensn new password:123456 retype new password:123456 …… （2）Home文件夹 # mkdir /etc
  • Learn Nodejs 01 toknowme nodejs
    （1）下载nodejs https://nodejs.org/download/ 选择相应的版本进行下载     （2）安装nodejs 安装的方式比较多，请baidu下 我这边下载的是“node-v0.12.7-linux-x64.tar.gz”这个版本 （1）上传服务器 （2）解压 tar -zxvf  node-v0.12.
  • jquery控制自动刷新的代码举例 xp9802 jquery
    1、html内容部分  复制代码代码示例: <div id='log_reload'> <select name="id_s" size="1"> <option value='2'>-2s-</option> <option value='3'>-3s-</option
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他