05rjyzl11

浏览: 145627 次
性别:
来自: 北京

最近访客更多访客>>

breezylee

laopo521anping

wolfwell

gzjhqh

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

转: SpringBoot编写自定义的starter

博客分类：

杂七杂八

转：SpringBoot编写自定义的starter

原文：http://www.importnew.com/24164.html

原文出处： fangjian

在之前的文章中，我们分析过SpringBoot内部的自动化配置原理和自动化配置注解开关原理。

我们先简单分析一下mybatis starter的编写，然后再编写自定义的starter。

mybatis中的autoconfigure模块中使用了一个叫做MybatisAutoConfiguration的自动化配置类。

这个MybatisAutoConfiguration需要在这些Condition条件下才会执行：

@ConditionalOnClass({ SqlSessionFactory.class, SqlSessionFactoryBean.class })。需要SqlSessionFactory和SqlSessionFactoryBean在classpath中都存在
@ConditionalOnBean(DataSource.class)。 spring factory中需要存在一个DataSource的bean
@AutoConfigureAfter(DataSourceAutoConfiguration.class)。需要在DataSourceAutoConfiguration自动化配置之后进行配置，因为mybatis需要数据源的支持

同时在META-INF目录下有个spring.factories这个properties文件，而且它的key为org.springframework.boot.autoconfigure.EnableAutoConfiguration，这样才会被springboot加载：

# Auto Configure
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
org.mybatis.spring.boot.autoconfigure.MybatisAutoConfiguration

有了这些东西之后，mybatis相关的配置会被自动加入到spring container中，只要在maven中加入starter即可：

<dependency>

    <groupId>org.mybatis.spring.boot</groupId>

    <artifactId>mybatis-spring-boot-starter</artifactId>

    <version>1.1.1</version>

</dependency>

编写自定义的starter

接下来，我们来编写自定义的starter：log-starter。

这个starter内部定义了一个注解，使用这个注解修饰方法之后，该方法的调用会在日志中被打印并且还会打印出方法的耗时。starter支持exclude配置，在exclude中出现的方法不会进行计算。

pom文件：

<parent>

    <groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starters</artifactId>

    <version>1.3.5.RELEASE</version>

</parent>
 
<dependencies>

    <dependency>

        <groupId>org.springframework.boot</groupId>

        <artifactId>spring-boot-starter</artifactId>

    </dependency>

</dependencies>

定义修饰方法的注解@Log：

package me.format.springboot.log.annotation;
 
import java.lang.annotation.ElementType;

import java.lang.annotation.Retention;

import java.lang.annotation.RetentionPolicy;

import java.lang.annotation.Target;    
 
@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface Log { }

然后是配置类：

package me.format.springboot.log.autoconfigure;
 
import org.springframework.boot.context.properties.ConfigurationProperties;

import org.springframework.util.StringUtils;
 
import javax.annotation.PostConstruct;
 
@ConfigurationProperties(prefix = "mylog")

public class LogProperties {
 
    private String exclude;
 
    private String[] excludeArr;
 
    @PostConstruct

    public void init() {

        this.excludeArr = StringUtils.split(exclude, ",");

    }
 
    public String getExclude() {

        return exclude;

    }
 
    public void setExclude(String exclude) {

        this.exclude = exclude;

    }
 
    public String[] getExcludeArr() {

        return excludeArr;

    }
}

接下来是AutoConfiguration：

package me.format.springboot.log.autoconfigure;
 
import me.format.springboot.log.annotation.Log;

import me.format.springboot.log.aop.LogMethodInterceptor;

import org.aopalliance.aop.Advice;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.aop.Pointcut;

import org.springframework.aop.support.AbstractPointcutAdvisor;

import org.springframework.aop.support.annotation.AnnotationMatchingPointcut;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.context.properties.EnableConfigurationProperties;

import org.springframework.context.annotation.Configuration;
 
import javax.annotation.PostConstruct;
 
@Configuration

@EnableConfigurationProperties(LogProperties.class)

public class LogAutoConfiguration extends AbstractPointcutAdvisor {
 
    private Logger logger = LoggerFactory.getLogger(LogAutoConfiguration.class);
 
    private Pointcut pointcut;
 
    private Advice advice;
 
    @Autowired

    private LogProperties logProperties;
 
    @PostConstruct

    public void init() {

        logger.info("init LogAutoConfiguration start");

        this.pointcut = new AnnotationMatchingPointcut(null, Log.class);

        this.advice = new LogMethodInterceptor(logProperties.getExcludeArr());

        logger.info("init LogAutoConfiguration end");

    }
 
    @Override

    public Pointcut getPointcut() {

        return this.pointcut;

    }
 
    @Override

    public Advice getAdvice() {

        return this.advice;

    }
 
}

由于计算方法调用的时候需要使用aop相关的lib，所以我们的AutoConfiguration继承了AbstractPointcutAdvisor。这样就有了Pointcut和Advice。Pointcut是一个支持注解的修饰方法的Pointcut，Advice则自己实现：

package me.format.springboot.log.aop;
 
import org.aopalliance.intercept.MethodInterceptor;

import org.aopalliance.intercept.MethodInvocation;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;
 
import java.util.Arrays;

import java.util.List;
 
public class LogMethodInterceptor implements MethodInterceptor {

    private Logger logger = LoggerFactory.getLogger(LogMethodInterceptor.class);

    private List<String> exclude;

    public LogMethodInterceptor(String[] exclude) {

        this.exclude = Arrays.asList(exclude);

    }

    @Override

    public Object invoke(MethodInvocation invocation) throws Throwable {

        String methodName = invocation.getMethod().getName();

        if(exclude.contains(methodName)) {

            return invocation.proceed();

        }

        long start = System.currentTimeMillis();

        Object result = invocation.proceed();

        long end = System.currentTimeMillis();

        logger.info("====method({}), cost({}) ", methodName, (end - start));

        return result;

    }
}

最后resources/META-INF/spring.factories中加入这个AutoConfiguration：

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
me.format.springboot.log.autoconfigure.LogAutoConfiguration

我们在项目中使用这个log-starter：

<dependency>

    <groupId>me.format.springboot</groupId>

    <artifactId>log-starter</artifactId>

    <version>1.0-SNAPSHOT</version>

</dependency>

使用配置：

mylog.exclude=core,log

然后编写一个简单的Service：

@Service

public class SimpleService {
 
    @Log

    public void test(int num) {

        System.out.println("----test---- " + num);

    }
 
    @Log

    public void core(int num) {

        System.out.println("----core---- " + num);

    }
 
    public void work(int num) {

        System.out.println("----work---- " + num);

    }
 
}

使用单元测试分别调用这3个方法，由于work方法没有加上@Log注解，core方法虽然加上了@Log注解，但是在配置中被exclude了，只有test方法可以正常计算耗时：

----test---- 666

2016-11-16 01:29:32.255  INFO 41010 --- [           main] m.f.s.log.aop.LogMethodInterceptor       : ====method(test),     cost(36) 

----work---- 666

----core---- 666

总结：

自定义springboot的starter，注意这两点。

如果自动化配置类需要在程序启动的时候就加载，可以在META-INF/spring.factories文件中定义。如果本次加载还需要其他一些lib的话，可以使用ConditionalOnClass注解协助
如果自动化配置类要在使用自定义注解后才加载，可以使用自定义注解+@Import注解或@ImportSelector注解完成

参考：

http://www.jianshu.com/p/85460c1d835a

http://docs.spring.io/spring-boot/docs/current/reference/html/boot-features-developing-auto-configuration.html

分享到：

转Dubbo服务治理 | @ControllerAdvice 和 @ExceptionHandler

2018-05-20 22:14
浏览 716
评论(0)
分类:编程语言
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

转: SpringBoot编写自定义的starter

转：SpringBoot编写自定义的starter

编写自定义的starter

评论

发表评论

相关推荐

最近访客 更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论

转: SpringBoot编写自定义的starter

转：SpringBoot编写自定义的starter

编写自定义的starter

评论

发表评论

相关推荐

转---openssl生成RSA格式的公私钥，并转为pkcs8格式

Java volatile

tomcat 内存设置

转 因采用 Flask 原生 WSGI 出现 "Broken pipe" 报错的故障处理

scala命令行进入粘贴模式 scala> :paste

nohup python hsbankTelnet.py >/dev/null 2>&1 &

tomcat访问日志 ip 请求次数

docker 学习笔记

大数据学习笔记11：分布式环境下的强一致性若一致性

大数据学习笔记10：一致性哈希

大数据学习笔记9：python 基础学习六 引入模块

大数据学习笔记8：python 基础学习五 异常

大数据学习笔记7：python 基础学习四 字符串

大数据学习笔记6：python 基础学习三 if for while

大数据学习笔记5：python 基础学习二 dict list set

大数据学习笔记4：python 基础学习一

大数据学习笔记2：安装jdk

openssl 生成pfx

加密解密中的 .pfx文件

转Dubbo服务治理

最近访客更多访客>>

转因采用 Flask 原生 WSGI 出现 "Broken pipe" 报错的故障处理

大数据学习笔记9：python 基础学习六引入模块

大数据学习笔记8：python 基础学习五异常

大数据学习笔记7：python 基础学习四字符串