Spring Boot微服务

EventPublishingRunListener

• 如果要自定义一个SpringApplicationRunListener实现,需要做如下两步

  • 新建一个实现类

  public class DemoApplicationRunListener implements SpringApplicationRunListener
  

  • 在当前SpringBoot应用的classpath下的META-INF/spring.factories文件中进行如下配置

  org.springframework.boot.SpringApplicationRunListener=com.lyf.springboot.demo.DemoApplicationRunListener
  

@ApplicationListener

• 监听者模式
• 为SpringBoot添加自定义ApplicationListener有两种方式

1. 经验证,最新SpringBoot版本没有以下静态方法

   SpringApplication.addListeners(...) 或者 SpringApplication.setListeners(...)
   

2. 在当前SpringBoot应用的classpath下的META-INF/spring.factories文件中进行如下配置

   org.springframework.context.=com.lyf.springboot.demo.DemoApplicationListener
   

@ApplicationContextInitializer

• 该类主要目的就是在ConfigurableApplicationContext类型(或子类型)的SpringApplication做refresh之前,允许我们对ConfigurableApplicationContext实例做进一步设置处理
• 自定义ApplicationContextInitializer方法为

public class DemoApplicationContextInitializer implements ApplicationContextInitializer{
    @Override
    public void initialize(ConfigurableApplicationContext applicationContext) {
        // do whatever you want with applicationContext,
        // e.g. applicationContext.registerShutdownHook();
    }
}

• 注册自定义方法也是在当前SpringBoot应用的classpath下的META-INF/spring.factories文件中进行配置

CommandLineRunner

• 它不是Spring框架原有的,属于SpringBoot应用特定的回调扩展接口

public interface CommandLineRunner {
    void run(String... args) throws Exception;
}

• 它的执行点在SpringBoot应用的ApplicationContext完全初始化开始工作之后(可认为是main执行完成之前最后一步)
• 当前SpringBoot应用的ApplicationContext中的任何CommandLineRunner,都会被加载执行
• 实现方式

标注@org.springframework.core.annotation.Order
或
实现org.springframework.core.annotation.Order接口

spring-boot-starter

spring-boot-starter在Spring Boot生态中被称为Starter POMs。Starter POMs是一系列轻便的依赖包，是一套一站式的Spring相关技术解决方案。开发者在使用和整合模块时，不必再去搜寻样例代码中的依赖配置来复制使用，只需要引入对应的模块包即可，比如，开发Web应用时，就引入spring-boot-starter-web, 希望应用具备数据库访问能力的时候，那就引入spring-boot-starter-jdbc

• SpringBoot两个重要特性:
  • 约定优于配置(COC)
  • 开箱即用. SpringBoot提供的开箱即用模块都约定以spring-boot-start-作为命名前缀
• 对SpringBoot行为干预的配置方式有(优先级由高到低,优先级高的覆盖低的)
  • 命令行参数
  • 系统环境变量
  • 文件系统中的配置文件
  • classpath中的配置文件
  • 固化到代码中的配置项
• SpringBoot应用默认的配置文件位置/application.properties或/config/application.properties

spring-boot-starter-logging

为SpringBoot引入应用日志框架,以下选择一种,注意一定不要将这些完成同一目的的spring-boog-starter都引入

/application.properties
logging.level.root=debug

• logback
  引入依赖后开箱即用

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

配置方式有两种
* 遵循logback约定,在classpath中使用自定义的logback.xml配置文件
* application.properties中使用logging.config配置项指向logback.xml配置文件
logging.config=/{some.path.you.defined}/logback.xml

• log4j

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

• log4j2

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

spring-boot-starter-web

• 用于使用SpringMVC开发web应用(打包形式为jar)

• 非Web应用使用spring-boot-starter

• 引入

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

• 项目结构约定

• SpringMVC层面的约定和定制

• 嵌入式Web容器层面约定和定制

  • spring-boot-starter-web默认使用嵌入式tomcat,端口8080
  • 如果不想使用默认的嵌入式tomcat(spring-boot-starter-tomcat), 可以引入spring-boot-starter-jetty或spring-boot-starter-undertow替代
  • 修改Web容器配置项
    jar包启动指定端口号可以增加参数 -Dserver.port=8080

  //application.properties
  server.port = 9000
  server.address =
  server.ssl.*
  server.tomcat.*
  

  • 以上配置项仍无法满足需求,可向IoC容器注册一个EmbeddedServletContainerCustomizer类型的组件对嵌入式Web容器进行定制

  @Configuration
  public class DemoEmbeddedServletContainerCustomizer implements EmbeddedServletContainerCustomizer {
      @Override
      public void customize(ConfigurableEmbeddedServletContainer container) {
          container.setPort(9999);
          container.setContextPath("/demo-project");
          //...
      }
  }
  

  • 再深入定制则需要针对特定的嵌入式Web容器,使用实现对应的Factory并注册到IoC容器

    • TomcatEmbeddedServletContainerFactory
    • JettyEmbeddedServletContainerFactory
    • UndertowEmbeddedServletContainerFactory

  • JSP支持(需要打包成war,不能为jar)

    • 引入依赖

    //注意版本,最新的tomcat-embed-jasper版本可能会启动报错
    compile("org.apache.tomcat.embed:tomcat-embed-jasper:8.5.8")
    compile("javax.servlet:jstl:1.2")
    

    • application.properties

    spring.mvc.view.prefix=/WEB-INF/views/
    

spring.mvc.view.suffix=.jsp
```

    * 目录结构,由于tomcat硬编码的原因, 对目录结构有要求,webapp还是需要的

      ![目录结构](http://upload-images.jianshu.io/upload_images/5748528-832609f7cd383a5e.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

打包成可执行war

• URL
• 引入springboot gradle插件

apply plugin: 'org.springframework.boot'
buildscript {
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:1.4.2.RELEASE")
    }
}
buildscript {
    repositories {
        maven {
            name 'Aliyun Maven Repository'
            url 'http://maven.aliyun.com/nexus/content/groups/public'
        }
    }
}

• 使用gradle bootRepackage进行打包
• 运行java -jar /Users/luyunfei/Documents/dev/workspace/zxd-oa/build/libs/zxd-oa.war

spring-boot-starter-jdbc

• 更多的数据库访问模块:spring-boot-starter-mongodb

• 默认使用tomcat JDBC连接池,Tomcat7之前，Tomcat本质应用了DBCP连接池技术来实现的JDBC数据源，但在Tomcat7之后，Tomcat提供了新的JDBC连接池方案，作为DBCP的替换或备选方案，解决了许多之前使用DBCP的不利之处，并提高了性能.其它连接池还有c3p0,Druid(淘宝开源)

• 默认情况,如果没有配置任何DataSource,SpringBoot会自动配置一个基于嵌入式数据库的DataSource, 该行为很适合测试场景

• 如果只依赖一个数据库,可使用如下配置

  //application.properties
  spring.datasource.url = jdbc:mysql://{database host}:3306/{databaseName}
  spring.datasource.username = {database username}
  spring.datasource.password = {database password}
  

• 除了DataSource会自动配置,SpringBoot还会自动配置相应的JdbcTemplate,DataSourceTransactionManager等关联设施,使用时按如下注入即可

  class SomeDao{
      JdbcTemplate jdbcTemplate;
      public <T> List<T> queryForList(String sql){
          //...
      }
  }
  

• 如果依赖多个数据库，使用如下配置在启动时会抛出异常

  //异常信息:No qualifying bean of type {javax.sql.DataSource} is defined: expected single matching bean bug found 2
  @Bean
  //解决方案: 在这里添加@Primary,告诉Spring在出现多个时,优先选择这个
  public DataSource dataSource1() throws Throwable{
      /*数据库连接池,类似的还有：
      *dbcp(有时候会自动断掉,必须重启才能有效)
      *C3P0(偶尔断掉,无须重启)
      *Druid性能较dbcp,c3p0优越很多(淘宝开源)
      *默认的tomcat 连接池
      */
      DruidDataSource dataSource = new DruidDataSource();
      dataSource.setUrl(...);
      dataSource.setUsername(...);
      dataSource.setPassword(...);
      return dataSource;
  }
  @Bean
  public DataSource dataSource2() throws Throwable{
      ...
  }
  

  还有一种方案时排除掉SpringBoot默认提供的DataSource相关自动配置

  @SpringBootApplication(exclude = {DataSourceAutoConfiguration.class, DataSourceTransactionManagerAutoConfiguration.class})
  public class DemoApplication {
  
      public static void main(String[] args) {
          SpringApplication.run(DemoApplication.class, args);
      }
  }
  

• 数据库版本化管理

  • 作用: 针对数据库的变更进行版本化管理(注意不要跟mybatis,hibernate等持久化框架搞混).即多个人接触数据库,当对表,字段或数据修改后(DDL,DML),又怎么来同步呢?解决各环境的数据库不一致问题(即将DDL,DML放到项目的sql文件中,由migrations框架自动提交到数据库中,类似于hibernate map文件增加字段后,在程序启动时,自动将增加的字段修改到DB中而无须对DB执行DML操作)
  • 实践方案
    • Ruby On Rails的migration支持
    • Java 的MyBatis Migrations(非MyBatis)
    • Flyway
    • Liquibase
  • SpringBoot提供针对Flyway,Liquibase的自动配置功能(org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration)
  • 两种版本化管理方式(注意不能说哪方式绝对的好,各有有缺点,应该按实际情况进行取舍)
  

  版本化管理方式

  • 对比

spring-boot-starter-aop

• AOP(Aspect Oriented Programming)

• 自动配置行为由两部分组成

  • spring-boot-autoconfigure的org.springframework.boot.autoconfigure.aop.AopAutoConfiguration提供@Configuration配置类和相应配置项，如下

    //application.properties
    spring.aop.auto = false(关闭自动aop配置)
    spring.aop.proxy-target-class=true(启用class而非interface级别的aop代理)
    

  • spring-boot-starter-aop 模块自身提供针对spring-aop,aspectjrt和aspectjweaver的依赖

• step-step: 定义Aop 手动搭建metrics-spring(未调试成功,略),直接可用方案

  • 引入依赖compile("org.springframework.boot:spring-boot-starter-aop:1.4.0.RELEASE")
  • 定义aop类

  @Component
  @Aspect
  public class AutoMetricsAspect {
  
      //切点
      @Pointcut(value = "execution(public * *(..))")
      public void publicMethods() {
  
      }
      //各切面的实现逻辑,函数名称任意
      @Before(" publicMethods() && @annotation(countedAnnotation) ")
      public void instrumentCounted(JoinPoint jp, Counted countedAnnotation) {...}
  
      @Before(" publicMethods() && @annotation(meteredAnnotation) ")
      public void instrumentMetered(JoinPoint jp, Metered meteredAnnotation) {...}
  
      @AfterThrowing(pointcut = " publicMethods() && @annotation(exMeteredAnnotation)", throwing = "ex")
      public void instrumentExceptionMetered(JoinPoint jp, Throwable ex, ExceptionMetered exMeteredAnnotation) {...}
  
      @Around(" publicMethods() && @annotation(timedAnnotation) ")
      public Object instrumentTimed(ProceedingJoinPoint pjp, Timed timedAnnotation) throws Throwable {...}
  }
  

  • 以上, 写一个方法进行测试即可

spring-boot-starter-security

• 引用 compile("org.springframework.boot:spring-boot-starter-security:1.4.0.RELEASE")
• SpringSecurity核心概念示意图

SpringSecurity核心概念示意图

• Spring Security的Web安全方案基于Java的Servlet API规范构建,因此使用javax.servlet.Filter实现"关卡"，制作关卡过程如下:

  • 实现GenericFilterBean,并注册到IoC容器

  public class SignCheckFilter extends GenericFilterBean {...}
  

  • 启用:在web.xml或JavaConfig配置中声明一个DelegatingFilterProxy,使其filter-name与自定义关卡挂钩

      <filter>
          <filter-name>signCheckFilter</filter-name>
          <filter-class>com.lyf.demo.filter.SignCheckFilter</filter-class>
      </filter>
      <filter-mapping>
          <filter-name>signCheckFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  

• Spring Security 的Web方案也是如上原理，过程如下(源码)

  • 实现GenericFilterBean,并注册到IoC容器

  public class DelegatingFilterProxy extends GenericFilterBean{...}
  

  • 启用(类似如下方式)

      <filter>
          <filter-name>springSecurityFilterChain(默认名称)</filter-name>
          <filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
      </filter>
      <filter-mapping>
          <filter-name>springSecurityFilterChain</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
  

  

  FilterSecurityInterceptor相关组件关系示意图

  • Spring内置Filter

  /*
  三类:
      1.信道与状态管理
      2. Web安全防护
      3. 认证和授权
  */
  FilterComparator() {
      int order = 100;
      put(ChannelProcessingFilter.class, order);//用于处理http或https之间的切换(信道与状态管理)
      order += STEP;
      put(ConcurrentSessionFilter.class, order);
      order += STEP;
      put(WebAsyncManagerIntegrationFilter.class, order);
      order += STEP;
      put(SecurityContextPersistenceFilter.class, order);//用于重建或者销毁必要的SecurityContext状态(信道与状态管理)
      order += STEP;
      put(HeaderWriterFilter.class, order);
      order += STEP;
      put(CorsFilter.class, order);
      order += STEP;
      put(CsrfFilter.class, order);//Web安全防护
      order += STEP;
      put(LogoutFilter.class, order);
      order += STEP;
      put(X509AuthenticationFilter.class, order);
      order += STEP;
      put(AbstractPreAuthenticatedProcessingFilter.class, order);
      order += STEP;
      filterToOrder.put("org.springframework.security.cas.web.CasAuthenticationFilter",
              order);//认证和授权
      order += STEP;
      put(UsernamePasswordAuthenticationFilter.class, order);
      order += STEP;
      put(ConcurrentSessionFilter.class, order);
      order += STEP;
      filterToOrder.put(
              "org.springframework.security.openid.OpenIDAuthenticationFilter", order);
      order += STEP;
      put(DefaultLoginPageGeneratingFilter.class, order);
      order += STEP;
      put(ConcurrentSessionFilter.class, order);
      order += STEP;
      put(DigestAuthenticationFilter.class, order);
      order += STEP;
      put(BasicAuthenticationFilter.class, order);//认证和授权
      order += STEP;
      put(RequestCacheAwareFilter.class, order);
      order += STEP;
      put(SecurityContextHolderAwareRequestFilter.class, order);
      order += STEP;
      put(JaasApiIntegrationFilter.class, order);
      order += STEP;
      put(RememberMeAuthenticationFilter.class, order);
      order += STEP;
      put(AnonymousAuthenticationFilter.class, order);
      order += STEP;
      put(SessionManagementFilter.class, order);
      order += STEP;
      //ExceptionTranslationFilter负责接待或送客,如果访客来访,对方没有报上名来,则让访客去找AuthenticationManager登记认证;如果对方报上名却认证失败了,则请重新认证或者走人.它拒绝访客的方式是抛出相应的Exception
      put(ExceptionTranslationFilter.class, order);
      order += STEP;
      put(FilterSecurityInterceptor.class, order);//即前面说到的securedObject(Filter
      Invocation)的关卡
      order += STEP;
      put(SwitchUserFilter.class, order);
  }
  

---

HOLD进程

try {
            Thread.currentThread().join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }