springboot心得笔记-入门

最新推荐文章于 2024-06-12 23:38:02 发布
最新推荐文章于 2024-06-12 23:38:02 发布
阅读量1.8k 收藏 3
点赞数
分类专栏： Spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liaomin416100569/article/details/78111004
版权

一。springboot简介

   Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。

springboot中文文档：https://www.breakyizhan.com/springboot/3028.html
springboot官方文档：https://spring.io/projects/spring-boot#learn

二。springboot容器

  spring容器提供了bean的创建和管理  spring沿用spring容器  提供了简化的操作方式 全程使用注解  以下通过实例讲解bean的管理 构建项目使用maven

1》helloworld 

  使用maven建立普通的maven jar项目

 》》pom.xml内容（可以通过sts生成）

 

<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>

	<groupId>cn.et</groupId>
	<artifactId>sb</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>sb</name>
	<description></description>
        <!--集成springboot的父项目 统一进行版本管理-->
	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.7</java.version>
	</properties>
        <!--springbbot添加web支持  spring所有的库 基本使用spring-boot-starter开头
            所有库参考 https://docs.spring.io/spring-boot/docs/1.5.7.RELEASE/reference/htmlsingle/#using-boot-starter
        -->
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
                <!--springboot测试库-->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>
        <!--springboot项目发布 使用spring-boot-maven-plugin插件-->
	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>
</project>

创建包 cn.et.learn01创建类SbApplication 用于启动springboot

 

 

@ComponentScan("cn.et.learn01") 自动扫描和装配 （@Controller Component等） @ComponentScan指定扫描特定的包 默认是扫描当前main的子包
@EnableAutoConfiguration   启用自动配置 后续讲解
public class SbApplication {

	public static void main(String[] args) {
		SpringApplication.run(SbApplication.class, args);
	}
}

添加springmvc的控制类 cn.et.learn01.controller.TestController   默认springboot只会扫描启动类相同包或者子包中带有注解的bean

 

 

package cn.et.learn01.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import cn.et.learn01.resource.MyConfig;
import cn.et.learn01.resource.MyConfigSource;

@RestController
public class TestController {

	@GetMapping("/query/{id}")
	public String query(@PathVariable String id) {
		return "hello"+id;
	}
}


运行主类SbApplication  通过日志查看发现默认启动了tomcat端口 8080

 

访问 http://localhost:8080/query/123   发现打印 hello123

springboot默认读取src/main/resources下的application.properties或者application.yml文件 该文件时springboot的配置文件

 比如配置端口  server.port=80 可以修改tomcat端口 其他配置参考springboot官方文档

（https://docs.spring.io/spring-boot/docs/1.5.7.RELEASE/reference/htmlsingle/#common-application-properties）

2》springboot自动扫描和装配

   springboot自动扫描沿用spring的方式 @ComponentScan扫描某个包及其子包下所有带有 spring常用注解的类 并自动创建bean

 也可以使用 @SpringBootApplication自动扫描当前主类当前包和子包下所有的注解类SpringBootApplication 也是由hello程序这些注解组成 查看源码

 

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration
@EnableAutoConfiguration  自动化配置
@ComponentScan(excludeFilters = {  控件扫描
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
public @interface SpringBootApplication {其他代码不贴出}


bean和bean之间自动装配只用  @AutoWired或者@Resouce 比如修改TestController类 添加容器ApplicationContext 就可以通过容器获取其他bean信息

 

 

@Autowired
ApplicationContext ac;

 

3》springboot资源文件读取

资源文件读取
@Value直接获取所有导入的资源文件 默认资源文件 application.properties
@PropertySource 指定加载的properties文件 这些加载的文件和 application.properties的键值对
  都可以使用 @Value获取 已经加载的后面的不能覆盖
@ConfigurationProperties 指定就某些前缀的资源 自动装配到属性中 不需要使用 @Value注解

实例测试 

  src/main/resources添加资源文件  a.properties

 

my1.name=ls
my1.sex=girl
my.jj=large

 

application.properties中添加

 

my.name=zs
my.sex=boy

 

 

添加类 MyConfigSource.java

 

 

package cn.et.learn01.resource;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
@Component
@PropertySource("classpath:a.properties") //将a.properties中的键值对 写入spring容器环境中
public class MyConfigSource {
	@Value("${my1.name}")  //通过Value注解 使用表达式获取
	private String name;
	@Value("${my1.sex}")
	private String sex;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	
}


使用 @ConfigurationProperties 可以不使用@Value

 

创建类MyConfig

 

package cn.et.learn01.resource;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;
@Component
@PropertySource("classpath:a.properties")
@ConfigurationProperties(prefix="my") //此时my前缀开头的 my.name和my.sex在application.properties中 my.jj在 a.properties都能正常读取
public class MyConfig {
	private String name;
	private String sex;
	private String jj;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}
	public String getJj() {
		return jj;
	}
	public void setJj(String jj) {
		this.jj = jj;
	}	
}

修改TestController注入两个bean

 

 

package cn.et.learn01.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import cn.et.learn01.resource.MyConfig;
import cn.et.learn01.resource.MyConfigSource;

@RestController
public class TestController {	
	@Autowired
	MyConfig config;
	@Autowired
	MyConfigSource configSource;
	@GetMapping("/query/{id}")
	public String query(@PathVariable String id) {
		return "hello"+config.getName()+"=>"+configSource.getName()+"=>"+config.getJj();
	}
}

正常输出配置文件中的数据 说明成功读取配置文件

 


3》@Configuration动态注入bean

   使用 @Compont等注解注入的bean不能进行一些复杂 动态的参数处理  使用 @Configuration可以做到 

在spring中bean的定义一般为

   spring.xml

 

<beans>
  <bean id="user" class="cn.e.User"/>
  <bean id="role" class="cn.e.Role"/>
</beans>

使用注解来配置（这里假设存在User和Role这两个类 ）

 

 

package cn.et.learn02.resource;

import cn.e.User
import cn.e.Role
/**
	@ConditionalOnBean（仅仅在当前上下文中存在某个对象时，才会实例化一个Bean）
	@ConditionalOnClass（某个class位于类路径上，才会实例化一个Bean）
	@ConditionalOnExpression（当表达式为true的时候，才会实例化一个Bean）
	@ConditionalOnMissingBean（仅仅在当前上下文中不存在某个对象时，才会实例化一个Bean）
	@ConditionalOnMissingClass（某个class类路径上不存在的时候，才会实例化一个Bean）
	@ConditionalOnNotWebApplication（不是web应用）
 * @author jiaozi
 *  
 */
//如果在类路径上存在MyConfig 才创建bean
@ConditionalOnClass(User.class)
@Configuration
public class MyConfiguration {
	//没有myUser 这个bean就创建
	@ConditionalOnMissingBean(name="myUser")
	@Bean
	public User myUser() {
		User my=new User();
		return my;
	}
	@Bean
	public Role myRole() {
		Role my=new Role();
		return my;
	}
}

如果在一个@Configuration引用其他的包下 @Configuration标注的类 可以使用

 

@Import注解导入 导入的类可以没有@Configuration注解

 

三。springboot自动配置

   通过研究@EnableAutoConfiguration源码 发现spring-boot-autoconfigure-1.5.7.RELEASE.jar/META-INF下存在一个spring.factories 其中定义了所有的自动启动的配置类  org.springframework.boot.autoconfigure.EnableAutoConfiguration=@Configuration注解的类实际上就是springboot默认不扫描jar包中的@Configuration注解的类 而是通过 EnableAutoConfiguration读取 该配置文件下配置的类 

 

# 初始化器 创建ApplicationContext对象 调用refresh方法创建并实例之前  可以进行一些bean的定义修改等此时只有bean的定义 还没有实例化
org.springframework.context.ApplicationContextInitializer=\
org.springframework.boot.autoconfigure.SharedMetadataReaderFactoryContextInitializer,\
org.springframework.boot.autoconfigure.logging.AutoConfigurationReportLoggingInitializer

# 启动事件监听 
org.springframework.context.ApplicationListener=\
org.springframework.boot.autoconfigure.BackgroundPreinitializer

# 存在配置类被导入后触发的监听
org.springframework.boot.autoconfigure.AutoConfigurationImportListener=\
org.springframework.boot.autoconfigure.condition.ConditionEvaluationReportAutoConfigurationImportListener

# 配置导入过滤器
org.springframework.boot.autoconfigure.AutoConfigurationImportFilter=\
org.springframework.boot.autoconfigure.condition.OnClassCondition

# 启动时自动装载到容器的bean类
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,\
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

# 出现异常后的报告输出格式类
org.springframework.boot.diagnostics.FailureAnalyzer=\
org.springframework.boot.autoconfigure.diagnostics.analyzer.NoSuchBeanDefinitionFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.DataSourceBeanCreationFailureAnalyzer,\
org.springframework.boot.autoconfigure.jdbc.HikariDriverConfigurationFailureAnalyzer

# 可用的模板引擎提供类
org.springframework.boot.autoconfigure.template.TemplateAvailabilityProvider=\
org.springframework.boot.autoconfigure.freemarker.FreeMarkerTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.mustache.MustacheTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafTemplateAvailabilityProvider,\
org.springframework.boot.autoconfigure.web.JspTemplateAvailabilityProvider

接下来依次通过实例演示 初始化器 监听器 自动配置 异常报告

 

创建一个maven项目sbbean  同上添加依赖src/main/resources添加META-INF 添加spring.factories文件

1》springboot自动配置
   实现一个功能 当在主类上添加EnableSocket 启动开启一个ServletSocket对象 端口8899

 》》建立注解EnableSocket 

 

package com.et.learn03.resource;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import org.springframework.context.annotation.Import;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(MyMarkerConfiguration.class) //很重要 当任意类使用了该注解就会导入这个配置 这个配置就可以随便创建一个bean作为标志
public @interface EnableSocket {
	
}

》》标志配置类MyMarkerConfiguration

 

 

package com.et.learn03.resource;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
//使用了注解EnableSocket才会创建该配置类的Bean 
@Configuration
public class MyMarkerConfiguration {
	@Bean
	public Marker myMarkerBean() { //实例化一个myMarkerBean的标志bean
		return new Marker();
	}
	class Marker {
	}
}


添加一个当添加@EnableAutoConfiguration注解就会配置的类MyAutoConfiguretion

 

package com.et.learn03.resource;

import java.io.IOException;

import java.net.ServerSocket;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.condition.ConditionalOnBean;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration()
//只有存在MyMarkerConfiguration.Marker的bean在容器中才会实例化这个类下的所有bean
//也就是只有加了EnableSocket 注解才能有这个类的实例
@ConditionalOnBean(MyMarkerConfiguration.Marker.class)
public class MyAutoConfiguretion {//没有myConfig 这个bean就创建
  @ConditionalOnMissingBean(name="myServer")
  @Bean
  public ServerSocket myServer() throws IOException {
	final ServerSocket ss = new ServerSocket(8899);
	System.out.println("启动ServerSocket");
	String str=null;//str.toString();
	return ss;
  }
}


将该类配置到 spring.factories中

 

 

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
com.et.learn03.resource.MyAutoConfiguretion

配置好后将maven项目 执行 install安装到本地镜像库 安装之前最好添加一个主类 去掉测试类 有可能安装失败
当前项目pom配置为

<groupId>cn.et</groupId>
<artifactId>sbbean</artifactId>
<version>0.0.1-SNAPSHOT</version>

在添加一个测试项目 test 添加sbbean的依赖 （测试项目的包路径(cn.et.learn03)和sbbean项目（com.et.learn03）的包路径不能一样否则会被扫描 ）

 

 

<dependency>
			<groupId>cn.et</groupId>
	<artifactId>sbbean</artifactId>
	<version>0.0.1-SNAPSHOT</version>
		</dependency>
	</dependencies>

添加一个主类测试

package cn.et.learn03;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.context.annotation.ComponentScan;

import com.et.learn03.resource.EnableSocket;
/**
 * @EnableAutoConfiguration原理解析
 *   自动读取jar包中的 /MeTA-INF/spring.factories类    
 *   具体实现参考 sbbean项目
 * @author jiaozi
 *
 */

@EnableAutoConfiguration
@ComponentScan("cn.et.learn03")
@EnableSocket
public class SbApplication {

	public static void main(String[] args) {
		SpringApplication sa=new SpringApplication();
		sa.run(SbApplication.class, args);
	}
}

发现启动 打印了启动ServerSocket  telnet localhost 8899成功 说明开启了端口
主类中去掉启动ServerSocket 发现端口没有监听 成功
 

2》springboot初始化器

  springboot初始化器 用于在bean被实例化之前（ConfigurableApplicationContext的refresh方法时）修改bean一些信息 配置profile等

 初始化器 必须实现ApplicationContextInitializer接口实现 initialize方法 

sbean项目中添加 该接口的实现类MyInitBean 

 

package com.et.learn03.init;

import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.context.ApplicationContextInitializer;
import org.springframework.context.ConfigurableApplicationContext;

public class MyInitBean implements ApplicationContextInitializer<ConfigurableApplicationContext> {
        //在创建bean指定 还可以定义bean 类似于 <bean id="myUser" class="MyUser"> 这里假设MyUser类已经
	@Override
	public void initialize(ConfigurableApplicationContext applicationContext) {
		DefaultListableBeanFactory factory=(DefaultListableBeanFactory)applicationContext.getBeanFactory();
		BeanDefinition bd=BeanDefinitionBuilder.genericBeanDefinition(MyUser.class).getBeanDefinition(); 
		factory.registerBeanDefinition("myUser", bd);
	}

}

将该类配置到 spring.factories中

 

#创建ApplicationContext对象 调用refresh方法创建并实例之前  可以进行一些bean的定义修改等
#此时只有bean的定义 还没有实例化
org.springframework.context.ApplicationContextInitializer=\
com.et.learn03.init.MyInitBean

任意maven项目 controller类测试 注入MyUser 看是否能装配  

 

package cn.et.learn03.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.et.learn03.init.MyUser;

@RestController
public class TestController {

	@Autowired
	private MyUser myUser;
	@GetMapping("/accept/{id}")
	public String query(@PathVariable String id) {
		return "ok111234";
	}
}

能够成功启动 成功

 

3》springboot监听器

   spring事件机制是使用 订阅和发布模式  

   ApplicationContext类中 

        addApplicationListener 用于添加订阅者 订阅某一些事件

        publishEvent 用于发布一些事件

  一般在spring容器的启动过程中会经历四个事件 当在这四个过程中springboot自动发布该事件 如果应用定了该事件 自动触发回调

 四个事件为SpringApplicationEvent的子类 分别是：

 

 ApplicationStartingEvent 调用run方法启动时触发, bean处理之前 但是此时已经注册了listeners and initializers.
 ApplicationEnvironmentPreparedEvent 正在设置环境时触发, 此时 applicationcontext还没有创建
 ApplicationPreparedEvent 此时bean定义信息已经加载 还没有进行调用refresh处理bean的生命周期
 ApplicationReadyEvent 所有准备工作完成 可以对外提供服务了
 
 此外还提供了另外一个异常的事件处理
 ApplicationFailedEvent 启动时出现异常 自动发送该事件

 如果需要监听 必须实现ApplicationListener 这里为了测试直接监听SpringApplicationEvent 应该回调会调用四次 也可以单独监听某个事件

 

创建类MyListener

 

package com.et.learn03.listener;

import org.springframework.boot.context.event.SpringApplicationEvent;
import org.springframework.context.ApplicationListener;
/**
 * @author jiaozi
 *
 */
public class MyListener implements ApplicationListener<SpringApplicationEvent> {

	@Override
	public void onApplicationEvent(SpringApplicationEvent event) {
		System.out.println("事件被触发"+event.getClass().getTypeName());
	}

}

将该类配置到 spring.factories中

 

#启动事件监听 
org.springframework.context.ApplicationListener=\
com.et.learn03.listener.MyListener

添加任意maven项目引用 该jar依赖后 尝试启动 发现控制台输出四次 

 

4》springboot异常报告

  在springboot启动时 出现异常可以使用异常报告拦截 并输出指定报告信息

创建异常报告类 拦截空指针异常

 

package com.et.learn03.fail;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.boot.diagnostics.FailureAnalysis;
import org.springframework.boot.diagnostics.analyzer.AbstractInjectionFailureAnalyzer;

public class MyExceptionFAilureAnalyzer extends AbstractInjectionFailureAnalyzer<NullPointerException> implements BeanFactoryAware {

	@Override
	public void setBeanFactory(BeanFactory arg0) throws BeansException {
		// TODO Auto-generated method stub

	}

	@Override
	protected FailureAnalysis analyze(Throwable arg0, NullPointerException arg1, String arg2) {
	
		FailureAnalysis fa=new FailureAnalysis("出现空指针异常"+arg1.getMessage(), "你好", arg0);
		return fa;
	}

}

将该类配置到 spring.factories中

 

 

# 失败分析器 当启动时出现某些异常  可以通过程序截获并分析
org.springframework.boot.diagnostics.FailureAnalyzer=\
com.et.learn03.fail.MyExceptionFAilureAnalyzer

添加任意项目 在其中添加

String str=null;
str.toString();

发现启动时错误信息为 自定义的失败信息
 

 

 

 

liaomin416100569
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 事件监听 ApplicationListener
燕归来兮
03-30 434
原文链接 https://www.zhoutao123.com/page/book/springboot/category/dmsce7 更多技术文章 & 读书笔记 欢迎访问 燕归来兮 https://www.zhoutao123.com SpringBoot 提供了各种各样的时间监听器( _ApplicationListener 的子类 _)，用来订阅SpringBoot在运行阶段的各种事件，整体的这种方式实现的逻辑图如下图: 这个接口是应用的事件的监听器，基于观察者模式实现，从Spr.
springboot学习笔记
beidaol的专栏
04-16 427
说明 springboot:2.1.3.RELEASE jdk:1.8 IDEA读取properties配置文件的中文乱码问题 1、在application.prperties下添加 spring.banner.charset=utf-8 server.tomcat.uri-encoding=UTF-8 spring.http.encoding.charset=UTF-8 spring.http....
spirngboot链接SAP RFC.都是最新版，看上传时间.7z
08-02
自己花了不少时间折腾的，主要是那个jco中间包，花了10多c币啊，大家下载赚大了啊，sapjco30P
springboot之ApplicationListener
wang0907的博客
06-08 4485
1：spring中的events 我们知道，事件处理首先是事件，对于事件，spring定义了抽象类org.springframework.context.ApplicationEvent,实现了jdk的接口java.util.EventObject，源码如下： // 该抽象类需要被具体的事件实现才又意义，这也是设置为abstrac的原因 public abstract class ApplicationEvent extends EventObject { // 事件发生的时间点 private fi
第 4 章：从 Spring Framework 到 Spring Boot
最新发布
Binge毕设
06-12 857
如果工程的 Spring Bean 扫描路径是。
SpringBoot2 | SpringBoot监听器源码分析 | 自定义ApplicationListener（六）
程序员阿康
09-21 7002
概述 我们都知道Spring源码博大精深，阅读起来相对困难。原因之一就是内部用了大量的监听器，spring相关的框架，皆是如此，spring security，springBoot等。今天来看下springBoot监听器的应用。 因为springBoot是对spring的封装，所以springBoot的监听器的应用主要是在启动模块。 源码 springBoot监听器的主要分为两类，运行时监听...
springboot进行事件监听有四种方式
qianxiaopeng的专栏
01-08 2163
springboot进行事件监听有四种方式： 1.手工向ApplicationContext中添加监听器 2.将监听器装载入spring容器 3.在application.properties中配置监听器 4.通过@EventListener注解实现事件监听 讲到事件监听，这里我们说下自定义事件和自定义监听器类的实现方式： 自定义事件：继承自ApplicationEvent抽象类，然后定义自己的构...
Springboot开发笔记-maste
05-30
Springboot开发笔记-masteSpringboot开发笔记-maste
SpringBoot学习笔记 - 生成RESTful服务 - 项目Demo
12-07
在本篇SpringBoot学习笔记中，我们将探讨如何利用SpringBoot框架构建RESTful服务，并通过一个实际的项目Demo来加深理解。REST（Representational State Transfer）是一种软件架构风格，广泛应用于Web服务设计，它...
SpringBoot学习笔记 - First Spring Boot Application - 代码Demo
12-07
Getting Started Guides(0)：First Spring Boot Application https://blog.csdn.net/leo_luck/article/details/121767974
SpringBoot-Study--master.zip
07-17
这个资源提供了全面的SpringBoot代码示例和学习笔记，旨在帮助开发者深入理解和掌握SpringBoot框架，提升Java编程技能。SpringBoot是Spring生态系统中的一个模块，它简化了基于Spring的应用程序开发过程，通过自动...
springBoot笔记二-来自于百度文库1
08-08
在本篇【springBoot笔记二-来自于百度文库1】中，主要讲解了Spring Boot的基础概念、核心特性以及如何创建一个简单的Spring Boot项目。以下是详细的知识点解析： 1. **Spring Boot简介**： - Spring Boot是Spring...
SpringBoot核心机制三、ApplicationListener
roykingw的专栏
04-28 1290
文章目录一、事件监听器使用1、自己实现一个事件监听器2、事件监听器的其他配置方式：2.1 SpringApplication.addListener2.2 基于注解添加2.3 在SpringBoot的配置文件中配置二、核心机制解读三、SpringBoot中的核心实现 所有调试均使用SpringBoot 2.4.5版本。 ApplicationListener事件监听机制其实是由Spring提供的，应用内部的事件驱动机制。也就是Pub/Sub发布订阅机制在应用内部的实现。一般主要是用于监控应用内部的一些运
SpringBoot调用SAP接口（搭建部署）
qq_38414801的博客
03-03 2101
1、创建Maven项目，在src/main/resource目录下创建lib文件夹，导入sap依赖。2、pom.xml中引入以下依赖。3、创建工具类，SapUtils。
Springboot项目接入SAP系统使用sapjco3部署到阿里云k8s环境心得总结
03-15 1326
一：关于sapjco 官网：SAP Java Connector 其他不做赘述，网上能查，相信点进来的同学都有所了解了。 需要jar包，.so或者.dll文件的请自行准备。 二：关于笔者所用项目结构，及一些列设置 1.sdk项目pom中添加以下这段，因为是本地jar，groupId，artifactId，version都可以随便写，只要systemPath指向正确就行。 <dependency> <groupId>com.s
SpringBoot学习总结
Melekh_的博客
02-08 2440
目录 1、我的第一个SpringBoot项目 创建SpringBoot项目 如何修改端口号 2、SpringBoot自动装配原理 3、yaml语法 用yaml赋值 配置文件占位符 结论： 4、JSR303数据校验及多环境切换 5、整合JDBC，Druid，Mybatis 1.整合JDBC 2.整合Druid 3.整合Mybatis 6、SpringSecurity 实验环境搭建 认识SpringSecurity 认证和授权 1.引入 Spring Security 模块.
Java连接SAP RFC 实现数据抽取
m0_71777195的博客
08-02 275
连接SAP入参获取出参获取函数列表获取表名获取函数执行执行结果获取。
关于SpringBoot课程（心得）
2303_76929548的博客
10-25 134
SpringBoot基于Spring4.0设计，不仅继承了Spring框架原有的优秀特性，而且还通过简化配置来进一步简化了Spring应用的整个搭建和开发过程。另外SpringBoot通过集成大量的框架使得依赖包的版本冲突，以及引用的不稳定性等问题得到了很好的解决。一、SpringBoot是什么？是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。二、
latex教程--latex排版学习笔记---入门提高
07-30
首先，初学者可以选择最基础的LaTeX入门教程，了解LaTeX的基本语法和命令。这些教程通常会介绍如何建立LaTeX文档框架、使用不同的字体和排版效果，以及如何插入数学公式等常见的操作。初学者可以通过参考这些教程来...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值