BlogJava-paulwong-随笔分类-SPRING

MONGODB SPRING DISTINCT

paulwong — Tue, 18 Oct 2022 02:22:00 GMT

SPRING 框架下如果要做去重，在数据量大的时候会爆ERROR，可改用如下写法：

  private boolean needReorderCheck(String requestId) {
        boolean result = false;
//        try(MongoCursor mongoCursor =
//                mongoTemplate.getCollection(mongoTemplate.getCollectionName(AccountNumProductLineIndex.class))
//                             .distinct(KEY, Filters.eq(REQUEST_ID, requestId), String.class)
//                             .iterator()
//                )
        try(MongoCursor mongoCursor =
                mongoTemplate.getCollection(mongoTemplate.getCollectionName(AccountNumProductLineIndex.class))
                             .aggregate(
                                 Arrays.asList(
                                    Aggregates.project(
                                                    Projections.fields(
                                                                    Projections.excludeId(),
                                                                   Projections.include(KEY),
                                                                   Projections.include(REQUEST_ID)
                                                                )
                                               ),
                                    Aggregates.match(Filters.eq(REQUEST_ID, requestId)),
                                    Aggregates.group("$" + KEY)
                                 )
                              )
                             .allowDiskUse(true)
                             .iterator();
        )
        {
            String key = null;
            boolean breakMe = false;
            LOGGER.info("needReorderCheck.key --> start");
            while(mongoCursor.hasNext()) {
                if(breakMe) {
                    mongoCursor.close();
                    break;
                }
                Document keyDocument = mongoCursor.next();
                key = keyDocument.getString("_id");
//                key = mongoCursor.next().getString(KEY);
//                LOGGER.info("needReorderCheck.keyDocument --> {}, key --> {}", keyDocument, key);
                try(MongoCursor indexMongoCursor =
                        mongoTemplate.getCollection(AccountNumProductLineIndex.COLLECTION_NAME)
                                        .find(Filters.and(Filters.eq(REQUEST_ID, requestId), Filters.eq(KEY, key)))
                                        .iterator()
                )
                {
                    int preIndex = -1, currentIndex = -1;
                    Document preIndexDocument = null, currentIndexDocument;
                    while(indexMongoCursor.hasNext()) {
                        currentIndexDocument = indexMongoCursor.next();
//                        System.out.println(currentIndexDocument.toJson());
                        if(preIndexDocument != null) {
                             currentIndex = currentIndexDocument.getInteger(INDEX);
                             preIndex = preIndexDocument.getInteger(INDEX);
                             if(currentIndex - preIndex > 1) {
                                indexMongoCursor.close();
                                breakMe = true;
                                result = true;
                                break;
                            }
                        }
                        preIndexDocument = currentIndexDocument;
                    }
                }
            }
        }

        return result;
    }

paulwong 2022-10-18 10:22 发表评论

Downloading Large Files using Spring WebClient

paulwong — Thu, 22 Sep 2022 05:14:00 GMT

https://www.amitph.com/spring-webclient-large-file-download/

https://github.com/amitrp/spring-examples/blob/main/spring-webflux-webclient/src/main/java/com/amitph/spring/webclients/service/FileDownloaderWebClientService.java

import lombok.RequiredArgsConstructor;
import org.springframework.core.io.buffer.DataBuffer;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardOpenOption;
import java.util.Objects;

@Service
@RequiredArgsConstructor
public class FileDownloaderWebClientService {
    private final WebClient webClient;

    /**
     * Reads the complete file in-memory. Thus, only useful for very large file
     */
    public void downloadUsingByteArray(Path destination) throws IOException {
        Mono<byte[]> monoContents = webClient
                .get()
                .uri("/largefiles/1")
                .retrieve()
                .bodyToMono(byte[].class);

        Files.write(destination, Objects.requireNonNull(monoContents.share().block()),
                StandardOpenOption.CREATE);
    }

    /**
     * Reading file using Mono will try to fit the entire file into the DataBuffer.
     * Results in exception when the file is larger than the DataBuffer capacity.
     */
    public void downloadUsingMono(Path destination) {
        Mono dataBuffer = webClient
                .get()
                .uri("/largefiles/1")
                .retrieve()
                .bodyToMono(DataBuffer.class);

        DataBufferUtils.write(dataBuffer, destination,
                StandardOpenOption.CREATE)
                .share().block();
    }

    /**
     * Having using Flux we can download files of any size safely.
     * Optionally, we can configure DataBuffer capacity for better memory utilization.
     */
    public void downloadUsingFlux(Path destination) {
        Flux dataBuffer = webClient
                .get()
                .uri("/largefiles/1")
                .retrieve()
                .bodyToFlux(DataBuffer.class);

        DataBufferUtils.write(dataBuffer, destination,
                StandardOpenOption.CREATE)
                .share().block();
    }
}

paulwong 2022-09-22 13:14 发表评论

SPRING INTEGRATION - ENRICH

paulwong — Tue, 21 Sep 2021 05:40:00 GMT

enrich时可以发起一个子流程，取得结果后再设置回当前的对象中。

package org.springframework.integration.stackoverflow.enricher;

import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.http.HttpMethod;
import org.springframework.integration.dsl.IntegrationFlow;
import org.springframework.integration.dsl.IntegrationFlows;
import org.springframework.integration.dsl.Transformers;
import org.springframework.integration.http.dsl.Http;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class SpringIntegrationEnricherApplication {

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

    @Bean
    public IntegrationFlow jsonEnricherFlow(RestTemplate restTemplate) {
        return IntegrationFlows.from(Function.class)
                .transform(Transformers.fromJson(Map.class))
                .enrich((enricher) -> enricher
                        .>requestPayload((message) ->
                                ((List) message.getPayload().get("attributeIds"))
                                        .stream()
                                        .map(Object::toString)
                                        .collect(Collectors.joining(",")))
                        .requestSubFlow((subFlow) ->
                                subFlow.handle(
                                        Http.outboundGateway("/attributes?id={ids}", restTemplate)
                                                .httpMethod(HttpMethod.GET)
                                                .expectedResponseType(Map.class)
                                                .uriVariable("ids", "payload")))
                        .propertyExpression("attributes", "payload.attributes"))
                ., Map>transform(
                        (payload) -> {
                            payload.remove("attributeIds");
                            return payload;
                        })
                .transform(Transformers.toJson())
                .get();
    }

}

https://stackoverflow.com/questions/58205432/spring-integration-enrich-transform-message-using-rest-call

https://www.tabnine.com/web/assistant/code/rs/5c781b6ae70f87000197ab9f#L312

paulwong 2021-09-21 13:40 发表评论

SRPING自带的事件监听机制

paulwong — Fri, 09 Apr 2021 06:55:00 GMT

定义一个事件，因SPRING中可以有不同的事件，需要定义一个类以作区分：

import lombok.Getter;
import org.springframework.context.ApplicationEvent;

@Getter
public class JavaStackEvent extends ApplicationEvent {

    /**
     * Create a new {@code ApplicationEvent}.
     *
     * @param source the object on which the event initially occurred or with
     *               which the event is associated (never {@code null})
     */
    public JavaStackEvent(Object source) {
        super(source);
    }

}

定义一个此事件观察者，即感兴趣者：

import lombok.NonNull;
import lombok.RequiredArgsConstructor;
import org.springframework.context.ApplicationListener;
import org.springframework.scheduling.annotation.Async;

/**
* 观察者：读者粉丝
*/
@RequiredArgsConstructor
public class ReaderListener implements ApplicationListener {

    @NonNull
    private String name;

    private String article;

    @Async
    @Override
    public void onApplicationEvent(JavaStackEvent event) {
        // 更新文章
        updateArticle(event);
    }

    private void updateArticle(JavaStackEvent event) {
        this.article = (String) event.getSource();
        System.out.printf("我是读者：%s，文章已更新为：%s\n", this.name, this.article);
    }

}

注册感兴趣者（将自身注入SPRING容器则完成注册），并制定发布机制（通过CONTEXT发布事件）：

import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Slf4j
@Configuration
public class ObserverConfiguration {

    @Bean
    public CommandLineRunner commandLineRunner(ApplicationContext context) {
        return (args) -> {
            log.info("发布事件：什么是观察者模式？");
            context.publishEvent(new JavaStackEvent("什么是观察者模式？"));
        };
    }

    @Bean
    public ReaderListener readerListener1(){
        return new ReaderListener("小明");
    }

    @Bean
    public ReaderListener readerListener2(){
        return new ReaderListener("小张");
    }

    @Bean
    public ReaderListener readerListener3(){
        return new ReaderListener("小爱");
    }

}

paulwong 2021-04-09 14:55 发表评论

csv 文件打开乱码，有哪些方法可以解决？

paulwong — Tue, 23 Mar 2021 02:30:00 GMT

Excel 在读取 csv 的时候是通过读取文件头上的 bom 来识别编码的，这导致如果我们生成 csv 文件的平台输出无 bom 头编码的 csv 文件（例如 utf-8 ，在标准中默认是可以没有 bom 头的），Excel 只能自动按照默认编码读取，不一致就会出现乱码问题了。

掌握了这点相信乱码已经无法阻挡我们前进的步伐了：只需将不带 bom 头编码的 csv 文件，用文本编辑器（工具随意，推荐 notepad++ ）打开并转换为带 bom 的编码形式（具体编码方式随意），问题解决。

当然，如果你是像我一样的码农哥哥，在生成 csv 文件的时候写入 bom 头更直接点，用户会感谢你的。

附录：对于 utf-8 编码，unicode 标准中是没有 bom 定义的，微软在自己的 utf-8 格式的文本文件之前加上了EF BB BF三个字节作为识别此编码的 bom 头，这也解释了为啥大部分乱码都是 utf-8 编码导致的原因

SPRING BATCH中生成CSV文件时的解决方案：

new FlatFileItemWriterBuilder()
      .name(itemWriterName)
      .resource(outputResource)
      .lineAggregator(lineAggregator)
      .headerCallback(
      h -> {
               System.out.println(header);
               h.write('\uFEFF');//只需加这一行
               h.write(header);
           }
      )
      .build();

https://stackoverflow.com/questions/48952319/send-csv-file-encoded-in-utf-8-with-bom-in-java

paulwong 2021-03-23 10:30 发表评论

JSR-303 Bean Validation - Date String Validation

paulwong — Thu, 25 Feb 2021 01:44:00 GMT

@Past @Future只针对Date类型的验证，如果是String类型的验证，则不适用。
其实可以新加一个方法返回Date类型，再配合@Future@Past 进行验证。

@Future(message = "Invalid CN_ID_INFO.EXPIRE_DATE.")
private LocalDate getValidExpireDate() {
    try {
        return LocalDate.parse(this.dateString, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    } catch (Exception e) {
        return null;
    }
}

此方法对dateString进行解释，返回LocalDate，如果dateString为空或格式错误，则返回空，再配合@Future 进行是否未来日期的验证。

paulwong 2021-02-25 09:44 发表评论

JSR-303 Bean Validation - Conditional Validation

paulwong — Thu, 25 Feb 2021 01:24:00 GMT

bean validation的注释是针对单个变量的，如果要针对多个变量的联动，则不行，需要用到这个注释。
这种方法避免了自定义校验器而增加类。
https://www.chkui.com/article/java/java_bean_validation

@AssertTrue(message = "Missing BANK_CARD_IMG_INFO.IMG")
private Boolean getValidImg() {
    if(YNEnum.Y.code.equals(super.getNeedChecked())) {
            return StringUtils.hasText(this.img);
        }
        return null;//igore checking.
}

这个是当needChecked为Y的时候才执行检查img变量是否为空。
有几点注意：

方法名称要以get开头
返回类型用Boolean，而不用boolean
返回值有三种：true,false,null如果是null则当成通过，与true的结果一样

paulwong 2021-02-25 09:24 发表评论

JSR-303 Bean Validation

paulwong — Thu, 28 Jan 2021 02:35:00 GMT

接收数据的JAVA BEAN通常需要验证其中字段的正确性，如不准为空，符合EMAIL格式等。

JSR-303 Bean Validation则提供了这样的便捷。

只要在JAVA BEAN中需要验证的字段加@NotNull这种标签，然后在SERVISE中的输入参数中加@Valid标签，则就激活验证流程。
也可以编程的方式自己验证：

@MessageEndpoint
//@Validated
public class MqMessageCcdValidator {

    private static final Logger LOGGER = LoggerFactory.getLogger(MqMessageCcdValidator.class);

    @Autowired
    private Validator validator;

    @ServiceActivator
    public MqMessage validate(/* @Valid */ Message> requestMessage) {
        Set>> set = validator.validate(requestMessage.getPayload());
        if(CollectionUtils.isNotEmpty(set)) {
            CompositeException compositeException = new CompositeException();
            set.forEach(
                constraintViolation -> {
                                            LOGGER.info("{}", constraintViolation);
                                            ReqInfoValidationException exception =
                                                    new ReqInfoValidationException(constraintViolation.getMessage());
                                            compositeException.addException(exception);
                                       }
            );
            throw new MessageHandlingException(requestMessage, compositeException);
        }

        return requestMessage.getPayload();
    }

}

自定义验证规则
可用标签来做，以下为验证手机号的规则：

import static java.lang.annotation.RetentionPolicy.RUNTIME;

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

import javax.validation.Constraint;
import javax.validation.Payload;
import javax.validation.ReportAsSingleViolation;
import javax.validation.constraints.Pattern;

@Retention(RUNTIME)
@Target(value = { ElementType.FIELD, ElementType.PARAMETER, ElementType.ANNOTATION_TYPE })
@Constraint(validatedBy = {})
@ReportAsSingleViolation
@Pattern(regexp = "^1[3-9]\\d{9}$")
public @interface ChinaPhone {
    String message() default "Invalid Chinese mobile No.";
    Class[] groups() default {};
    Classextends Payload>[] payload() default {};
}

如果比较复杂的验证规则，则参见：
https://reflectoring.io/bean-validation-with-spring-boot/#implementing-a-custom-validator

How to use Java Bean Validation in Spring Boot
https://nullbeans.com/how-to-use-java-bean-validation-in-spring-boot/

Complete Guide to Validation With Spring Boot
https://reflectoring.io/bean-validation-with-spring-boot/

Spring JMS Validate Messages using JSR-303 Bean Validation
https://memorynotfound.com/spring-jms-validate-messages-jsr-303-bean-validation/

Spring REST Validation Example
https://mkyong.com/spring-boot/spring-rest-validation-example/

Spring Boot 整合 Bean Validation 校验数据

https://blog.csdn.net/wangzhihao1994/article/details/108403732

paulwong 2021-01-28 10:35 发表评论

SPRING INTEGRATION HEADER问题

paulwong — Tue, 20 Oct 2020 06:56:00 GMT

当SPRING INTEGRATION的流程中从HTTP outboundGateway转成JmsGateway时，会报header的错误，这时就要把相关多余的header移除。

.headerFilter("Api-Key", "Content-Type", "X-Powered-By", "Content-Language", "Transfer-Encoding", "Cache-Control", "Keep-Alive", "Set-Cookie")

https://stackoverflow.com/questions/50608415/cwsia0112e-the-property-name-keep-alive-is-not-a-valid-java-identifier

paulwong 2020-10-20 14:56 发表评论

RestTemplate处理请求状态码为非200的返回数据

paulwong — Fri, 16 Oct 2020 08:54:00 GMT

RestTemplate是Spring提供的用于访问Rest服务的客户端，

RestTemplate提供了多种便捷访问远程Http服务的方法,能够大大提高客户端的编写效率。

调用RestTemplate的默认构造函数，RestTemplate对象在底层通过使用java.net包下的实现创建HTTP 请求，

可以通过使用ClientHttpRequestFactory指定不同的HTTP请求方式。

ClientHttpRequestFactory接口主要提供了两种实现方式

1、一种是SimpleClientHttpRequestFactory，使用J2SE提供的方式（既java.net包提供的方式）创建底层的Http请求连接。

2、一种方式是使用HttpComponentsClientHttpRequestFactory方式，底层使用HttpClient访问远程的Http服务，使用HttpClient可以配置连接池和证书等信息。

默认的 RestTemplate 有个机制是请求状态码非200 就抛出异常，会中断接下来的操作。如果不想中断对结果数据得解析，可以通过覆盖默认的 ResponseErrorHandler ，见下面的示例，示例中的方法中基本都是空方法，只要对hasError修改下，让他一直返回true，即是不检查状态码及抛异常了。

package com.example.demo.web.config;

import java.io.IOException;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.client.ClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpResponse;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.web.client.ResponseErrorHandler;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    public RestTemplate restTemplate(ClientHttpRequestFactory factory) throws Exception {
        RestTemplate restTemplate = new RestTemplate(factory);
        ResponseErrorHandler responseErrorHandler = new ResponseErrorHandler() {
            @Override
            public boolean hasError(ClientHttpResponse clientHttpResponse) throws IOException {
                return true;
            }
            @Override
            public void handleError(ClientHttpResponse clientHttpResponse) throws IOException {
            }
        };
        restTemplate.setErrorHandler(responseErrorHandler);
        return restTemplate;
    }

    @Bean
    public ClientHttpRequestFactory simpleClientHttpRequestFactory(){
        SimpleClientHttpRequestFactory factory = new SimpleClientHttpRequestFactory();
        //读取超时5秒
        factory.setReadTimeout(5000);
        //连接超时15秒
        factory.setConnectTimeout(15000);
        return factory;
    }
}

RestTemppate运用实例

package com.example.demo.web.controller;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.example.demo.domain.Book;

@RestController
public class TestBookController {
    private Logger logger = LoggerFactory.getLogger(getClass());

      @Autowired
      private RestTemplate restTemplate;

      @GetMapping("/testaddbook")
      public Book testAddBook() {
              Book book = new Book();
              ResponseEntity responseEntity = restTemplate.postForEntity( "http://localhost:8061/book", book , Book.class);
              return responseEntity.getBody();
      }

}

其他方法，catch HttpStatusCodeException , e.getResponseBodyAsString()

try {
    ResponseEntity response = restTemplate.exchange(webSvcURL,
        HttpMethod.POST,
        requestEntity,
        Component.class);
} catch (HttpStatusCodeException e) {
    List customHeader = e.getResponseHeaders().get("x-app-err-id");
    String svcErrorMessageID = "";
    if (customHeader != null) {
        svcErrorMessageID = customHeader.get(0);
    }
    throw new CustomException(e.getMessage(), e, svcErrorMessageID);
    // You can get the body too but you will have to deserialize it yourself
    // e.getResponseBodyAsByteArray()
    // e.getResponseBodyAsString()
}

https://stackoverflow.com/questions/7878002/resttemplate-handling-response-headers-body-in-exceptions-restclientexception

https://stackoverflow.com/questions/38093388/spring-resttemplate-exception-handling/51805956#51805956

paulwong 2020-10-16 16:54 发表评论

Error handling in spring integration - How to get all the errors thrown in multiple threads and send them to the error-channel

paulwong — Thu, 15 Oct 2020 11:21:00 GMT

在SPRING INTEGRATION中，如果exception发生在各种thread里时，如何将exception返回到指定的channel，之后再绕回到aggrator-channel中。

@Bean
public IntegrationFlow provisionUserFlow() {
return
    IntegrationFlows.from("input.channel")
    .publishSubscribeChannel(Executors.newCachedThreadPool(),
        s -> s.applySequence(true)
            .subscribe(f -> f.enrichHeaders(e -> e.header(MessageHeaders.ERROR_CHANNEL, "errorChannel", true))
                .handle(provisionerA, "provision")
                .channel("aggregatorChannel")
            )
            .subscribe(f -> f.enrichHeaders(e -> e.header(MessageHeaders.ERROR_CHANNEL, "errorChannel", true))
                .handle(provisionerB, "provision")
                .channel("aggregatorChannel"))
            )
        .get();
}

@Bean
public IntegrationFlow aggregateFlow() {
  return IntegrationFlows.from("aggregatorChannel")
                    .channel( aggregatorChannel)
                    .aggregate( a -> a.processor( collect, "aggregatingMethod"))
                    .get();
}

@Transformer( inputChannel = "errorChannel", outputChannel = "aggregatorChannel")
public Message errorChannelHandler(ErrorMessage errorMessage) throws RuntimeException {

    Message failedMessage =  ((MessagingException) errorMessage.getPayload()).getFailedMessage();

    Exception exception = (Exception) errorMessage.getPayload();

  return  MessageBuilder.withPayload( exception.getMessage())
                                       .copyHeadersIfAbsent( failedMessage.getHeaders() )
                                       .build();
}

https://stackoverflow.com/q/46495127/11790720

paulwong 2020-10-15 19:21 发表评论

SPRING INTEGRATION子FLOW

paulwong — Thu, 15 Oct 2020 03:29:00 GMT

split-route-aggregate flow
split之后，可以将message分给不同的子flow处理，配置如下：

@Bean
public IntegrationFlow parallelSplitRouteAggregateFlow() {
    return IntegrationFlows
            .from(Http.inboundGateway("/trigger"))
            .handle((p, h) -> Arrays.asList(1, 2, 3))
            .split()
            .channel(MessageChannels.executor(Executors.newCachedThreadPool()))
            .route(o -> o % 2 == 0, m -> m
                    .subFlowMapping(true, sf -> sf.gateway(oddFlow()))
                    .subFlowMapping(false, sf -> sf.gateway(evenFlow())))
            .aggregate()
            .get();
}

@Bean
public IntegrationFlow oddFlow() {
    return flow -> flow.handle((payload, headers) -> "odd");
}

@Bean
public IntegrationFlow evenFlow() {
    return flow -> flow.handle((payload, headers) -> "even");
}

https://stackoverflow.com/questions/50121384/spring-integration-parallel-split-route-aggregate-flow-fails-due-to-one-way-mess

paulwong 2020-10-15 11:29 发表评论

怀旧框架集合

paulwong — Fri, 09 Oct 2020 11:14:00 GMT

摘要: 最近在公司用JUP框架做项目,发现这个框架是别人基于SpringSide封装的,所以打算学习下,SpringSide,其中遇到了很多坑,做个记录,网上关于这方面的资料都有些老了,而且SpringSide最新的版本是SpringSide-Utils,老一点的版本为v4.2.2.GA,以下分别对这两个版本分别介绍下,主要内容来自于网上。一些资料:Github源码地址: https://gi... 阅读全文

paulwong 2020-10-09 19:14 发表评论

Spring Retry框架——看这篇就够了

paulwong — Tue, 15 Sep 2020 05:39:00 GMT

https://my.oschina.net/marvelcode/blog/4563352

paulwong 2020-09-15 13:39 发表评论

LOGBACK FOR SPRING

paulwong — Tue, 19 Nov 2019 07:14:00 GMT

当程序中使用LOGGER.INFO("MESSAGE");要求打印日志时，LOGBACK会获取该行代码所在类的全名，和打印等级(INFO/DEBUG等)，再在配置文件的中查找对应logger，使用其配置的appender组件打印日志，如无法找到对应的logger，则使用对应的appender打印日志。

其中appender是用来输出日志，有file和console两个实现，console则是向控制台输出日志，而file则是向文件输出日志。
rolling file appender中，有rollingPolicy和triggerPolicy两个主要属性，rollingPolicy是确定如何处理日志文件，而triggerPolicy则是确定何时处理日志文件。

如果要使用SPRING针对LOGBACK的一些功能，如profile等，则要将logback.xml的配置文件命名为logback-spring.xml，并在SPRING中配置，logging.config= logback-spring.xml。

SPRING会将logging.file、logging.path这些配置转成系统变量LOG_FILE、LOG_PATH，可在配置文件中直接引用，如${LOG_FILE}。

如果logback配置文件要SPRING的其他属性，则要使用如下标签：

如果要使用LOGBACK的一些常用属性，可引入：

如CONSOLE APPENDER，此resource在spring-boot-version.jar中。

=========================================
看完这个不会配置 logback ，请你吃瓜！
https://juejin.im/post/5b51f85c5188251af91a7525

logback解析——Appender
https://juejin.im/post/5a39c91cf265da4327185d10

SpringBoot中logback.xml使用application.yml中属性
https://www.cnblogs.com/jianliang-Wu/p/8945343.html

springboot使用logback-spring.xml配置讲解
https://blog.csdn.net/heguiliang_123/article/details/80296745

Logback配置
https://www.cnblogs.com/cjsblog/p/9113131.html

Logback中如何自定义灵活的日志过滤规则
https://www.jianshu.com/p/d6360c517264

Spring Boot中的日志
http://loveshisong.cn/%E7%BC%96%E7%A8%8B%E6%8A%80%E6%9C%AF/2016-11-03-Spring-Boot%E4%B8%AD%E7%9A%84%E6%97%A5%E5%BF%97.html

Spring Boot与logback总结
https://blog.csdn.net/u014527058/article/details/79667458

SpringBoot Logback 配置参数迁移到配置中心 Apollo
https://blog.csdn.net/shuaizai88/article/details/83027262

paulwong 2019-11-19 15:14 发表评论

spring-loaded热部署

paulwong — Sun, 11 Sep 2016 02:40:00 GMT

什么是spring-loaded?

spring-loaded是一个对于jvm代理运行时期改变类文件的重载（重新加载），它转换类loadtime让他们服从后重新加载。不像“热代码替换”只允许一次简单的改变JVM运行(例如更改方法体)spring-loaded允许您添加/修改/删除/字段/方法构造函数。注释类型/方法/字段/构造函数也可以修改和可以添加/删除/修改值的枚举类型。

有什么好处?

开发测试阶段：能够在启动后动态更改代码调试,无需重启减少切换debug时间（ps:对于eclipse而言，在debug时期只能做到动态更新方法体不能增加）
对于线上测试发布阶段：能够在出现问题后直接替换class文件而不重启应用（ps:对于外部提供的服务jar形式同样能做到）
怎么使用?

项目地址

https://github.com/spring-projects/spring-loaded

第一步：下载文件
http://repo.spring.io/release/org/springframework/springloaded/1.2.5.RELEASE/springloaded-1.2.5.RELEASE.jar

第二步：配置jvm启动参数

eclipse

eclipse：run as --> run configurations --> arguments -->> VM arguments
-javaagent:E:\repository\org\springframework\spring-load\springloaded-1.2.5.RELEASE.jar
-noverify -Dspringloaded=verbose
详细描述：
-javaagent: 配置java代理使用下载后的jar包路径
-noverify: 禁用字节码验证
-Dspringloaded=verbose 显示springloaded时的详细信息

java命令启动

java -javaagent:E:\repository\org\springframework\spring-load\springloaded-1.2.5.RELEASE.jar -noverify Test  类似

java jar包动态替换

1.打成runnable Jar

2.命令启动：

java -javaagent:E:\repository\org\springframework\spring-load\springloaded-1.2.5.RELEASE.jar -noverify -Dspringloaded=watchJars=main.jar main.jar

/**  * 类Test.java的实现描述：TODO 类实现描述   * @author Administrator 2016年7月4日 下午4:55:59  */ public class Test {     public static void main(String[] args) throws InterruptedException {          while(true) {             try {                 println();                 Thread.sleep(1000);             } catch (Throwable e) {                  e.printStackTrace();              }          }       }     public static void println() {          System.out.println("112222221222222");          }  }

改变为

/**  * 类Test.java的实现描述：TODO 类实现描述   * @author Administrator 2016年7月4日 下午4:55:59  */ public class Test {     public static void main(String[] args) throws InterruptedException {          while(true) {             try {                 println();                 Thread.sleep(1000);             } catch (Throwable e) {                  e.printStackTrace();              }          }       }     public static void println() {          System.out.println("test replace jar");          }  }

3.重新打包替换

PS：实测在window下无用 手上无linux机器待测试

paulwong 2016-09-11 10:40 发表评论

SPRING MVC整合NETTY

paulwong — Tue, 19 Apr 2016 05:27:00 GMT

http://wenku.baidu.com/view/4573aba4ce2f0066f53322e8.html

paulwong 2016-04-19 13:27 发表评论

SPRING IO

paulwong — Fri, 30 Oct 2015 06:05:00 GMT

Spring起初只专注ioc和aop，现在已发展成一个庞大体系。比如security、mvc等。
如此一来，不同模块或者与外部进行集成时，依赖处理就需要各自对应版本号。
比如，较新spring与较老的quartz，它们集成就会遇到问题，给搭建和升级带来不便。

因此Spring IO Platform应运而生，只要项目中引入了它，外部集成时依赖关系无需版本号

<dependency>
<groupId>org.springframeworkgroupId>
<artifactId>spring-coreartifactId>
dependency>

Spring IO Platform只是一个pom文件，记录了spring与其他开源项目对应的版本。
省去了版本号，也就省去了处理依赖时的问题，因为Spring IO Platform中有最优的版本。

paulwong 2015-10-30 14:05 发表评论

Spring面试问答Top 25

paulwong — Thu, 30 Apr 2015 05:29:00 GMT

摘要: 问题清单：什么是Spring框架？Spring框架有哪些主要模块？使用Spring框架有什么好处？什么是控制反转（IOC）？什么是依赖注入？请解释下Spring中的IOC？BeanFactory和ApplicationContext有什么区别？将Spring配置到你的应用中共有几种方法？什么基于XML的配置？什么基Java的配置？怎样用注解的方式配置Spring？描述Spring Bean的生命周... 阅读全文

paulwong 2015-04-30 13:29 发表评论

SPRING CACHE之ConcurrentMapCacheManager改造

paulwong — Wed, 25 Feb 2015 08:34:00 GMT

ConcurrentMapCacheManager可以作为一种缓存方案，但不能设置过期，最大缓存条目等，需进行改造。

pom.xml中加入依赖包

  <dependency>
            <groupId>com.google.guavagroupId>
            <artifactId>guavaartifactId>
            <version>18.0version>
        dependency>
改造CacheManager，MyConcurrentMapCacheManager

package com.paul.common.cache;
/*
* Copyright 2002-2014 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*      http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.util.Collection;
import java.util.Collections;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;

import org.springframework.cache.Cache;
import org.springframework.cache.CacheManager;
import org.springframework.cache.concurrent.ConcurrentMapCache;

import com.google.common.cache.CacheBuilder;

/**
* {@link CacheManager} implementation that lazily builds {@link ConcurrentMapCache}
* instances for each {@link #getCache} request. Also supports a 'static' mode where
* the set of cache names is pre-defined through {@link #setCacheNames}, with no
* dynamic creation of further cache regions at runtime.
*
*
Note: This is by no means a sophisticated CacheManager; it comes with no
* cache configuration options. However, it may be useful for testing or simple
* caching scenarios. For advanced local caching needs, consider
* {@link org.springframework.cache.guava.GuavaCacheManager} or
* {@link org.springframework.cache.ehcache.EhCacheCacheManager}.
*
* @author Juergen Hoeller
* @since 3.1
* @see ConcurrentMapCache
*/
public class MyConcurrentMapCacheManager implements CacheManager {

    private final ConcurrentMap cacheMap = new ConcurrentHashMap(16);

    private boolean dynamic = true;

    private boolean allowNullValues = true;

    private long expireTime = 30;

    private long maximumSize = 100;

    /**
     * Construct a dynamic ConcurrentMapCacheManager,
     * lazily creating cache instances as they are being requested.
     */
    public MyConcurrentMapCacheManager() {
    }

    /**
     * Construct a static ConcurrentMapCacheManager,
     * managing caches for the specified cache names only.
     */
    public MyConcurrentMapCacheManager(long expireTime, long maximumSize) {
        if(expireTime > 0)
            this.expireTime = expireTime;
        if(maximumSize > 0)
            this.maximumSize = maximumSize;
    }

    /**
     * Specify the set of cache names for this CacheManager's 'static' mode.
     *
The number of caches and their names will be fixed after a call to this method,
     * with no creation of further cache regions at runtime.
     *
Calling this with a {@code null} collection argument resets the
     * mode to 'dynamic', allowing for further creation of caches again.
     */
    public void setCacheNames(Collection cacheNames) {
        if (cacheNames != null) {
            for (String name : cacheNames) {
                this.cacheMap.put(name, createConcurrentMapCache(name));
            }
            this.dynamic = false;
        }
        else {
            this.dynamic = true;
        }
    }

    /**
     * Specify whether to accept and convert {@code null} values for all caches
     * in this cache manager.
     *
Default is "true", despite ConcurrentHashMap itself not supporting {@code null}
     * values. An internal holder object will be used to store user-level {@code null}s.
     *
Note: A change of the null-value setting will reset all existing caches,
     * if any, to reconfigure them with the new null-value requirement.
     */
    public void setAllowNullValues(boolean allowNullValues) {
        if (allowNullValues != this.allowNullValues) {
            this.allowNullValues = allowNullValues;
            // Need to recreate all Cache instances with the new null-value configuration
            for (Map.Entry entry : this.cacheMap.entrySet()) {
                entry.setValue(createConcurrentMapCache(entry.getKey()));
            }
        }
    }

    /**
     * Return whether this cache manager accepts and converts {@code null} values
     * for all of its caches.
     */
    public boolean isAllowNullValues() {
        return this.allowNullValues;
    }

    @Override
    public Collection getCacheNames() {
        return Collections.unmodifiableSet(this.cacheMap.keySet());
    }

    @Override
    public Cache getCache(String name) {
        Cache cache = this.cacheMap.get(name);
        if (cache == null && this.dynamic) {
            synchronized (this.cacheMap) {
                cache = this.cacheMap.get(name);
                if (cache == null) {
                    cache = createConcurrentMapCache(name);
                    this.cacheMap.put(name, cache);
                }
            }
        }
        return cache;
    }

    /**
     * Create a new ConcurrentMapCache instance for the specified cache name.
     * @param name the name of the cache
     * @return the ConcurrentMapCache (or a decorator thereof)
     */
    protected Cache createConcurrentMapCache(String name) {
//return new ConcurrentMapCache(name, isAllowNullValues());
//此处改用GOOGLE GUAVA的构造MANAGER方式
        return new ConcurrentMapCache(name,
                                        CacheBuilder.newBuilder()
                                                    .expireAfterWrite(this.expireTime, TimeUnit.MINUTES)
                                                    .maximumSize(this.maximumSize)
                                                    .build()
                                                    .asMap(),
                                        isAllowNullValues());
    }

}
配置想着bean, cache-concurrentmap-applicationcontext.xml
xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:cache="http://www.springframework.org/schema/cache"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:c="http://www.springframework.org/schema/c"
    xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/context
          http://www.springframework.org/schema/context/spring-context-3.0.xsd
          http://www.springframework.org/schema/beans
          http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
          http://www.springframework.org/schema/cache
          http://www.springframework.org/schema/cache/spring-cache.xsd
          http://www.springframework.org/schema/jee
          http://www.springframework.org/schema/jee/spring-jee.xsd
          http://www.springframework.org/schema/util
          http://www.springframework.org/schema/util/spring-util.xsd">

    <cache:annotation-driven />



    <bean id="cacheManager"
        class="com.paul.common.cache.MyConcurrentMapCacheManager">
        <constructor-arg index="0" value="1" />
        <constructor-arg index="1" value="5000" />
    bean>

beans>
通过注释进行使用

/*
* JBoss, Home of Professional Open Source
* Copyright 2014, Red Hat, Inc. and/or its affiliates, and individual
* contributors by the @authors tag. See the copyright.txt in the
* distribution for a full listing of individual contributors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* http://www.apache.org/licenses/LICENSE-2.0
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.paul.springmvc.data;

import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.paul.springmvc.model.Member;

@Repository
@Transactional
public class MemberDaoImpl implements MemberDao {
    @Autowired
    private EntityManager em;

    @Cacheable(value = "my-local-cache", key = "#id")
    public Member findById(Long id) {
        System.out.println("MemberDaoImpl NO CACHE");
        return em.find(Member.class, id);
    }

    public Member findByEmail(String email) {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery criteria = cb.createQuery(Member.class);
        Root member = criteria.from(Member.class);

        /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */

        criteria.select(member).where(cb.equal(member.get("email"), email));
        return em.createQuery(criteria).getSingleResult();
    }

    public List findAllOrderedByName() {
        CriteriaBuilder cb = em.getCriteriaBuilder();
        CriteriaQuery criteria = cb.createQuery(Member.class);
        Root member = criteria.from(Member.class);

        /*
         * Swap criteria statements if you would like to try out type-safe criteria queries, a new
         * feature in JPA 2.0 criteria.select(member).orderBy(cb.asc(member.get(Member_.name)));
         */

        criteria.select(member).orderBy(cb.asc(member.get("name")));
        return em.createQuery(criteria).getResultList();
    }

    @CacheEvict(value="my-local-cache",allEntries=true,beforeInvocation=true)//清空所有缓存
    public void register(Member member) {
        em.persist(member);
        return;
    }
}

paulwong 2015-02-25 16:34 发表评论

SPRING CACHE资源

paulwong — Wed, 25 Feb 2015 08:04:00 GMT

SPRING手册
http://docs.spring.io/spring/docs/3.2.x/spring-framework-reference/htmlsingle/#cache

SPRING CONCURRENTMAP MANAGER加过期策略
http://stackoverflow.com/questions/8181768/can-i-set-a-ttl-for-cacheable

组合KEY
http://stackoverflow.com/questions/14072380/cacheable-key-on-multiple-method-arguments

Spring Cache抽象详解
http://www.open-open.com/lib/view/open1389575623336.html

注释驱动的 Spring cache 缓存介绍
https://www.ibm.com/developerworks/cn/opensource/os-cn-spring-cache/

Spring Cache抽象详解

paulwong 2015-02-25 16:04 发表评论

Architecture for Redis cache & Mongo for persistence

paulwong — Sun, 04 Jan 2015 07:50:00 GMT

Caching with Spring Data Redis
http://www.javacodegeeks.com/2013/02/caching-with-spring-data-redis.html

Architecture for Redis cache & Mongo for persistence
http://stackoverflow.com/questions/11218941/architecture-for-redis-cache-mongo-for-persistence

MongoDB with redis
http://stackoverflow.com/questions/10696463/mongodb-with-redis/10721249#10721249

Caching Data in Spring Using Redis
http://caseyscarborough.com/blog/2014/12/18/caching-data-in-spring-using-redis/

Springside Redis
https://github.com/springside/springside4/wiki/Redis

Spring Cache注解+Redis
http://hanqunfeng.iteye.com/blog/2176172

paulwong 2015-01-04 15:50 发表评论

SPRING-SESSION

paulwong — Wed, 19 Nov 2014 10:23:00 GMT

摘要: HTTP SESSION的管理通常是由容器来做，但如果是在PAAS环境下，服务器不能做变更，则需要由WEB应用来做处理HTTP SESSION。同样，如果是分布式的环境下，SESSION的管理也会带来性能问题。SPRING推出了处理SESSION的框架：SPRING-SESSION。 SPRING会重写HTTP SESSION的那一套，使用SESSION也同样还是用 Code ... 阅读全文

paulwong 2014-11-19 18:23 发表评论

Spring Boot

paulwong — Sat, 11 Oct 2014 12:34:00 GMT

Spring Boot 在 Spring 生态中的位置：

https://github.com/spring-projects/spring-boot/tree/master/spring-boot-samples

paulwong 2014-10-11 20:34 发表评论

Spring对HttpSession的重新封闭

paulwong — Tue, 19 Aug 2014 01:13:00 GMT

https://github.com/spring-projects/spring-session/tree/master/samples

paulwong 2014-08-19 09:13 发表评论

自定义注释与操作行为记录

paulwong — Fri, 25 Jul 2014 06:56:00 GMT

自定义注释就是一个标记，一个信息收集器，如果配合SPRING的AOP使用，可以记录用户的操作行为。

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

/**
* 新增的用法:@Audit(behaviour="新增了专题",
*            value="#{args[0].colSubject}")
*
* 修改的用法:@Audit(behaviour="修改了专题", id="#{args[0].colSubject.id}",
*            className="com.paul.program.colsubject.valueobject.ColSubject",
*            value="#{args[0].colSubject}")
*
* 删除的用法:@Audit(behaviour="删除了专题", id="#{args[0].colSubject.id}"
*             className="com.paul.program.colsubject.valueobject.ColSubject")
*
* @author PAUL
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Audit {

    String id() default "";
    String className() default "";
    String collectionName() default "";
    String value() default "";
    String behaviour();

}

值对象
AuditData.java

package com.paul.common.audit;

import java.io.Serializable;
import java.util.Date;

import org.codehaus.jackson.annotate.JsonProperty;
import org.codehaus.jackson.map.annotate.JsonSerialize;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

import com.paul.common.util.jackson.CustomJsonDateSerializer;

@Document(collection = "auditdata")
public class AuditData implements Serializable{

    private static final long serialVersionUID = -4011585863836336249L;

    @Id
    private String id;

    @CreatedBy
    @Field("userid")
    @JsonProperty("userid")
    private String userId;

    @CreatedDate
    @Field("createdate")
    @JsonProperty("createdate")
    @JsonSerialize(using = CustomJsonDateSerializer.class)
    private Date createDate;

    private String behaviour;

    @Field("newvalue")
    @JsonProperty("newvalue")
    private String newValue;

    @Field("oldvalue")
    @JsonProperty("oldvalue")
    private String oldValue;

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public Date getCreateDate() {
        return createDate;
    }

    public void setCreateDate(Date createDate) {
        this.createDate = createDate;
    }

    public String getBehaviour() {
        return behaviour;
    }

    public void setBehaviour(String behaviour) {
        this.behaviour = behaviour;
    }

    public String getNewValue() {
        return newValue;
    }

    public void setNewValue(String newValue) {
        this.newValue = newValue;
    }

    public String getOldValue() {
        return oldValue;
    }

    public void setOldValue(String oldValue) {
        this.oldValue = oldValue;
    }

    public String toString() {
        return "AuditData [id=" + id + ", userId=" + userId + ", createDate="
                + createDate + ", behaviour=" + behaviour + ", newValue="
                + newValue + ", oldValue=" + oldValue + "]";
    }


}

RootObject.java

package com.paul.common.audit;

public class RootObject {

    private final Object[] args;

    private final Object invokedObject;

    private final Object returned;

    private final Throwable throwned;

    public RootObject(Object invokedObject, Object[] args, Object returned, Throwable throwned) {
        super();
        this.invokedObject = invokedObject;
        this.args = args;
        this.returned = returned;
        this.throwned = throwned;
    }

    public Object[] getArgs() {
        return args;
    }

    public Object getInvokedObject() {
        return invokedObject;
    }

    public Object getReturned() {
        return returned;
    }

    public Throwable getThrowned() {
        return throwned;
    }

}

TemplateParserContext.java

package com.paul.common.audit;

import org.springframework.expression.ParserContext;

public class TemplateParserContext implements ParserContext {

    public String getExpressionPrefix() {
        return "#{";
    }

    public String getExpressionSuffix() {
        return "}";
    }

    public boolean isTemplate() {
        return true;
    }
}

获取用户ID

package com.paul.common.audit.aware;

import javax.servlet.http.HttpServletRequest;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.domain.AuditorAware;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import com.paul.common.constant.Constants;
import com.paul.program.account.valueobject.Account;

@Component
public class MyAppAuditor implements AuditorAware {

    private static Logger logger = LoggerFactory.getLogger(MyAppAuditor.class);

    // get your user name here
    public String getCurrentAuditor() {

        String result = "N/A";
        try {
            HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder
                    .getRequestAttributes()).getRequest();
            Account account = (Account)request.getSession().getAttribute(Constants.USER_INFO);
            result = account.getLoginName();
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return result;
    }
}

切面

package com.paul.common.audit.interceptor;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.apache.commons.lang.builder.ToStringBuilder;
import org.apache.commons.lang.builder.ToStringStyle;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.Expression;
import org.springframework.expression.ExpressionParser;
import org.springframework.expression.ParseException;
import org.springframework.expression.ParserContext;
import org.springframework.expression.spel.standard.SpelExpressionParser;
import org.springframework.stereotype.Component;

import com.paul.common.audit.AuditData;
import com.paul.common.audit.AuditDataRequest;
import com.paul.common.audit.RootObject;
import com.paul.common.audit.TemplateParserContext;
import com.paul.common.audit.annotation.Audit;
import com.paul.common.audit.service.AuditDataService;
import com.paul.common.util.StringUtils;

@Component
@Aspect
public class AuditAspect {

    private static Logger logger = LoggerFactory.getLogger(AuditAspect.class);

    @Autowired
    private AuditDataService auditDataService;

    @Autowired
    private MongoTemplate mongoTemplate;

    private SimpleDateFormat dateFormatPrototype = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    private Map expressionCache = new ConcurrentHashMap();

    private ExpressionParser expressionParser = new SpelExpressionParser();

    private ParserContext parserContext = new TemplateParserContext();


    protected static void appendThrowableCauses(Throwable throwable, String separator, StringBuilder toAppendTo) {
        List alreadyAppendedThrowables = new ArrayList();

        while (throwable != null) {
            // append
            toAppendTo.append(throwable.toString());
            alreadyAppendedThrowables.add(throwable);

            // cause
            Throwable cause = throwable.getCause();
            if (cause == null || alreadyAppendedThrowables.contains(cause)) {
                break;
            } else {
                throwable = cause;
                toAppendTo.append(separator);
            }
        }
    }

    private String getValueByEl(String template, Object invokedObject, Object[] args, Object returned, Throwable throwned)
    {
        String result = "N/A";
        if(StringUtils.isBlank(template))
            return result;
        try {
            Expression expression = expressionCache.get(template);
            if (expression == null) {
                expression = expressionParser.parseExpression(template, parserContext);
                expressionCache.put(template, expression);
            }

            Object evaluatedMessage = expression.getValue(new RootObject(invokedObject, args, returned, throwned), Object.class);
            result = evaluatedMessage.toString();
        } catch (ParseException e) {
            logger.error(e.getMessage(), e);
        } catch (EvaluationException e) {
            logger.error(e.getMessage(), e);
        }
        return result;
    }

    protected AuditData buildAuditData(Audit auditAnnotation, Object invokedObject, Object[] args, Object returned, Throwable throwned, long durationInNanos) {

        AuditData auditData = new AuditData();
        auditData.setBehaviour(auditAnnotation.behaviour());
        String id = this.getValueByEl(auditAnnotation.id(), invokedObject, args, returned, throwned);
        auditData.setOldValue(this.getOldValueToString(id, auditAnnotation.className()));
        try {
            String newValue = this.getValueByEl(auditAnnotation.value(), invokedObject, args, returned, throwned);
            auditData.setNewValue(newValue);

            StringBuilder msg = new StringBuilder();

            SimpleDateFormat simpleDateFormat = (SimpleDateFormat) dateFormatPrototype.clone();
            msg.append(simpleDateFormat.format(new Date()));
//            auditData.setCreateDate(simpleDateFormat.format(new Date()));

            msg.append(" ").append(newValue);

            if (throwned != null) {
                msg.append(" threw '");
                appendThrowableCauses(throwned, ", ", msg);
                msg.append("'");
            }
            msg.append(" by ");
            String user = this.getUser();
            if (user == null) {
                user = "anonymous";
            }
            msg.append(" in ") .append(TimeUnit.MILLISECONDS.convert(durationInNanos, TimeUnit.NANOSECONDS)).append(" ms");
            return auditData;
        } catch (Exception e) {
            /*StringBuilder msg = new StringBuilder("Exception evaluating template '" + template + "': ");
            appendThrowableCauses(e, ", ", msg);*/
            return auditData;
        }
    }

    private String getOldValueToString(/*ProceedingJoinPoint proceedingJoinPoint,*/ String id, String className)
    {
        String result = "N/A";
        /*String id = "5385be613d2a47eec07c53d4";
        try {
            MethodSignature methodSig = (MethodSignature) proceedingJoinPoint.getSignature();
            Object target = proceedingJoinPoint.getTarget();
            Object newValue = proceedingJoinPoint.getArgs()[0];
            String findMethodName = "findOne";
            Object oldValue=null;
            Method findMethod = target.getClass().getDeclaredMethod(findMethodName, (Class[])null);
            oldValue = findMethod.invoke(target, (Object[]) null);

        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }*/
        if(StringUtils.isBlank(id) || StringUtils.isBlank(className))
            return result;

        try {
            Object object = mongoTemplate.findById(id, Class.forName(className));
            result = ToStringBuilder.reflectionToString(object,  ToStringStyle.SHORT_PREFIX_STYLE);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
        return result;
    }

//    @Around("execution(* com.paul..**.repository..*(..))")
    @Around("@annotation(auditAnnotation)")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint, Audit auditAnnotation) throws Throwable {

        boolean ok = false;
        Object o = null;
        AuditData auditData = null;
        try
        {
            auditData = buildAuditData(auditAnnotation, proceedingJoinPoint.getThis(),
                    proceedingJoinPoint.getArgs(),
                    o, null, 10);
            o = proceedingJoinPoint.proceed();
            ok = true;
            return o;
        }
        finally
        {
            if (ok)
            {
//                String value = (MessageFormat.format(auditAnnotation.value(), proceedingJoinPoint.getArgs()));
                try
                {
                    AuditDataRequest auditDataRequest = new AuditDataRequest();
                    auditDataRequest.setAuditData(auditData);
                    auditDataService.addAuditData(auditDataRequest);
                    logger.info(auditData + "");
                }
                catch (Exception e)
                {
                    logger.error(e.getMessage(), e);
                }
            }
        }
    }

    private String getUser()
    {
        return "Paul";
    }


}

保存至数据库

package com.paul.common.audit.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Service;

import com.paul.common.audit.AuditData;
import com.paul.common.audit.AuditDataRequest;
import com.paul.common.audit.annotation.Audit;
import com.paul.common.audit.repository.AuditDataRepository;
import com.paul.program.colsubject.valueobject.ColSubjectRequest;

@Service
public class AuditDataService {

    @Autowired
    private AuditDataRepository auditDataRepository;

//    @Audited(message = "save(#{args[0].name}, #{args[0].email}): #{returned?.id}")
    @Audit(behaviour="修改了审计", id="#{args[0].colSubject.id}",
            className="com.paul.program.colsubject.valueobject.ColSubject",
            value="#{args[0].colSubject}")
    public void saveObject(ColSubjectRequest colSubjectRequest)
    {

    }

    @Audit(behaviour="删除了专题", id="#{args[0]}",
             className="com.paul.program.subject.valueobject.Subject")
    public void delete(String id) {
    }

    @Audit(behaviour="新增了专题", value="#{args[0].colSubject}")
    public void add(ColSubjectRequest colSubjectRequest) {
    }

    public AuditData addAuditData(AuditDataRequest auditDataRequest)
    {
        return auditDataRepository.save(auditDataRequest.getAuditData());
    }

    public Page findAll(AuditDataRequest auditDataRequest)
    {
        Page page = auditDataRepository.findAll(auditDataRequest.getPageable());
        return page;
    }

}

DAO

package com.paul.common.audit.repository;

import org.springframework.data.repository.PagingAndSortingRepository;

import com.paul.common.audit.AuditData;

/**
* 审计
*
*/
public interface AuditDataRepository extends PagingAndSortingRepository{

}

paulwong 2014-07-25 14:56 发表评论

Audit in Spring AOP

paulwong — Fri, 18 Jul 2014 01:50:00 GMT

Auditing entities in Spring Data MongoDB
http://maciejwalkowiak.pl/blog/2013/05/24/auditing-entities-in-spring-data-mongodb/

xebia-spring-security-extras
https://github.com/xebia-france/xebia-spring-security-extras/wiki/AuditedAnnotation

Spring Logging using custom annotation
http://stackoverflow.com/questions/15298164/spring-logging-using-custom-annotation

Spring MVC and MongoDB - Auditing Actions
http://www.alexecollins.com/content/spring-mvc-and-mongodb-auditing-actions/

audit-aspectj
https://github.com/roghughe/captaindebug/tree/master/audit-aspectj

paulwong 2014-07-18 09:50 发表评论

Spring Data REST，Spring MVC的REST扩展

paulwong — Wed, 09 Jul 2014 09:36:00 GMT

http://spring.io/blog/2012/06/26/spring-data-rest-1-0-0-rc1-released

RESTify your JPA Entities
https://www.openshift.com/blogs/restify-your-jpa-entities

babdev-spring
https://github.com/gregorriegler/babdev-spring/tree/master/spring-data-rest

https://github.com/spring-projects/spring-data-rest

paulwong 2014-07-09 17:36 发表评论

Spring Data Dijkstra

paulwong — Tue, 01 Jul 2014 02:49:00 GMT

一大波Spring Data相关包：
Spring Data Dijkstra SR1 发布，该版本包含如下模块的 59 个问题修复：

Spring Data Commons 1.8.1 - Artifacts - JavaDocs - Documentation -Changelog
Spring Data JPA 1.6.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data MongoDB 1.5.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Neo4j 3.1.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Solr 1.2.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Couchbase 1.1.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Cassandra 1.0.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Elasticsearch 1.0.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Gemfire 1.4.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data Redis 1.3.1 - Artifacts - JavaDocs - Documentation - Changelog
Spring Data REST 2.1.1 - Artifacts - JavaDocs - Documentation - Changelog

建议所有 Dijkstra 用户升级，因为包含重要的 bug 修复。

paulwong 2014-07-01 10:49 发表评论

在EJB3的SESSION BEAN中使用SPRING BEAN

paulwong — Wed, 12 Feb 2014 08:43:00 GMT

EJB3 façade over Spring services
http://java.dzone.com/articles/ejb3-fa%C3%A7ade-over-spring

Using Spring’s EJB implementation support classes
http://docs.spring.io/spring/docs/current/spring-framework-reference/html/ejb.html#ejb-implementation-ejb3

import javax.ejb.Stateless;
import javax.interceptor.Interceptors;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ejb.interceptor.SpringBeanAutowiringInterceptor;

import ch.frankel.blog.ejb.spring.service.client.RandomGeneratorService;

@Stateless
@Interceptors(SpringBeanAutowiringInterceptor.class)
public class RandomGeneratorBean implements RandomGeneratorService {

    @Autowired
    private ch.frankel.blog.ejb.spring.service.RandomGeneratorService delegate;

    @Override
    public int generateNumber(int lowerLimit, int upperLimit) {

        return delegate.generateNumber(lowerLimit, upperLimit);
    }
}

paulwong 2014-02-12 16:43 发表评论