奇米色欧美一区二区三区,亚洲日本在线视频观看,国产精品91在线

MONGODB SPRING DISTINCT

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

SPRING 框架�?如果要做去重�Q�在数据量大的时候会爆ERROR�Q�可改用如下写法�Q?br />

  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时可以发起一个子��程�Q�取得结果后再设�|�回当前的对象中�?br />

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 发表评论

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

定义一个事�Ӟ��因SPRING中可以有不同的事�Ӟ��需要定义一个类以作区分�Q?br />

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);
    }

}

定义一个此事�g观察者，��x��兴趣者：

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

/**
* 观察者：读者粉�?br /> */
@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�Q�文章已更新为：%s\n", this.name, this.article);
    }

}

注册感兴��者（��自�w�注入SPRING容器则完成注册）�Q��ƈ制定发布机制�Q�通过CONTEXT发布事�g�Q�：

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("发布事�g�Q�什么是观察者模式？");
            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 发表评论

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

Excel 在读�?csv 的时候是通过��d��文�g头上�?bom 来识别编码的�Q�这��D��如果我们生成 csv 文�g的��^台输出无 bom 头编码的 csv 文�g�Q�例�?utf-8 �Q�在标准中默认是可以没有 bom 头的�Q�，Excel 只能自动按照默认�~�码��d��Q�不一致就会出��Cؕ码问题了�?br />
掌握了这点相信�ؕ码已�l�无法阻挡我们前�q�的步伐了：只需��不�?bom 头编码的 csv 文�g�Q�用文本�~�辑器（工具随意�Q�推�?notepad++ �Q�打开�q��{换�ؓ�?bom 的编码�Ş式（具体�~�码方式随意�Q�，问题解决�?br />
当然�Q�如果你是像我一��L��码农哥哥�Q�在生成 csv 文�g的时候写�?bom 头更直接点，用户会感谢你的�?br />
附录�Q�对�?utf-8 �~�码�Q�unicode 标准中是没有 bom 定义的，微��Y在自��q�� utf-8 格式的文本文件之前加上了EF BB BF三个字节作�ؓ识别此编码的 bom ��_��q�也解释了�ؓ啥大部分��q��都是 utf-8 �~�码��D��的原�?br />
SPRING BATCH中生成CSV文�g时的解决�Ҏ��Q?br />

new FlatFileItemWriterBuilder()
      .name(itemWriterName)
      .resource(outputResource)
      .lineAggregator(lineAggregator)
      .headerCallback(
      h -> {
               System.out.println(header);
               h.write('\uFEFF');//只需加这一�?/span>
               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�c�d��的验证，如果是String�c�d��的验证，则不适用�?br />其实可以新加一个方法返回Date�c�d��Q�再配合@Future@Past �q�行验证�?br />

@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�q�行解释�Q�返回LocalDate�Q�如果dateString为空或格式错误，则返回空�Q�再配合@Future �q�行是否未来日期的验证�?br />

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

JSR-303 Bean Validation - Conditional Validation

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

bean validation的注释是针对单个变量的，如果要针对多个变量的联动�Q�则不行�Q�需要用到这个注释�?br />�q�种�Ҏ��避免了自定义校验器而增加类�?br />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.
}

�q�个是当needChecked为Y的时候才执行��查img变量是否为空�?br />有几�Ҏ��意：

�Ҏ��名称要以get开�?br />
�q�回�c�d��用Boolean�Q�而不用boolean
�q�回值有三种�Q�true,false,null如果是null则当成通过�Q�与true的结果一�?/li>

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

JSR-303 Bean Validation

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

接收数据的JAVA BEAN通常需要验证其中字�D늚�正确性，如不准�ؓ�I�，�W�合EMAIL格式�{��?br />

JSR-303 Bean Validation则提供了�q�样的便捗��?br />
只要在JAVA BEAN中需要验证的字段加@NotNull�q�种标签�Q�然后在SERVISE中的输入参数中加@Valid标签�Q�则��激�z�验证流�E��?br />也可以编�E�的方式自己验证�Q?br />

@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();
    }

}

自定义验证规�?br />可用标签来做�Q�以下�ؓ验证手机��L��规则�Q?br />

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的流�E�中从HTTP outboundGateway转成JmsGateway�Ӟ��会报header的错误，�q�时��p��把相兛_��余的header�U�除�?br />

.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 发表评论

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

RestTemplate是Spring提供的用于访问Rest服务的客��L��Q?br />
RestTemplate提供了多�U�便捯��问远�E�Http服务的方�?能够大大提高客户端的�~�写效率�?br />
调用RestTemplate的默认构造函敎ͼ�RestTemplate对象在底层通过使用java.net包下的实现创建HTTP ��h��Q?br />
可以通过使用ClientHttpRequestFactory指定不同的HTTP��h��方式�?br />
ClientHttpRequestFactory接口主要提供了两�U�实现方�?br />
1、一�U�是SimpleClientHttpRequestFactory�Q��用J2SE提供的方式（既java.net包提供的方式�Q�创建底层的Http��h��q�接�?br />
2、一�U�方式是使用HttpComponentsClientHttpRequestFactory方式�Q�底层��用HttpClient讉K��q�程的Http服务�Q��用HttpClient可以配置�q�接池和证书�{�信息�?br />
默认�?RestTemplate 有个机制是请求状态码�?00 ��抛出异常，会中断接下来的操作。如果不想中断对�l�果数据得解析，可以通过覆盖默认�?ResponseErrorHandler �Q�见下面的示例，�C�Z��中的�Ҏ��中基本都是空�Ҏ��Q�只要对hasError修改下，让他一直返回true�Q�即是不��查状态码及抛异常了�?br />

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();
        //��d��时5�U?/span>
        factory.setReadTimeout(5000);
        //�q�接��时15�U?/span>
        factory.setConnectTimeout(15000);
        return factory;
    }
}

RestTemppate�q�用实例

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();
      }

}

其他�Ҏ��Q�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发生在各�U�thread里时�Q�如何将exception�q�回到指定的channel�Q�之后再�l�回到aggrator-channel中�?br />

@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之后�Q�可以将message分给不同的子flow处理�Q�配�|�如下：

@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

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

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

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会获取该行代码所在类的全名，和打印等�U?INFO/DEBUG�{?�Q�再在配�|�文件的中查扑֯�应logger�Q��用其配置的appender�l��g打印日志�Q�如无法扑ֈ�对应的logger�Q�则使用对应的appender打印日志�?br />
其中appender是用来输出日志，有file和console两个实现�Q�console则是向控制台输出日志�Q�而file则是向文件输出日志�?br />rolling file appender中，有rollingPolicy和triggerPolicy两个主要属性，rollingPolicy是确定如何处理日志文�Ӟ��而triggerPolicy则是��定何时处理日志文�g�?br />
如果要��用SPRING针对LOGBACK的一些功能，如profile�{�，则要��logback.xml的配�|�文件命名�ؓlogback-spring.xml�Q��ƈ在SPRING中配�|�，logging.config= logback-spring.xml�?br />
SPRING会将logging.file、logging.path�q�些配置转成�pȝ��变量LOG_FILE、LOG_PATH�Q�可在配�|�文件中直接引用�Q�如${LOG_FILE}�?br />
如果logback配置文�g要SPRING的其他属性，则要使用如下标签�Q?br />

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

如CONSOLE APPENDER�Q�此resource在spring-boot-version.jar中�?br />

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

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

SpringBoot中logback.xml使用application.yml中属�?br />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中如何自定义灉|��的日志过滤规�?br />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 配置参数�q�移到配�|�中�?Apollo
https://blog.csdn.net/shuaizai88/article/details/83027262

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

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

什么是spring-loaded?

spring-loaded是一个对于jvm代理�q�行时期改变�c�L��件的重蝲�Q�重新加载）�Q�它转换�c�loadtime让他们服从后重新加蝲。不�?#8220;热代码替�?#8221;只允�怸��ơ简单的改变JVM�q�行(例如更改�Ҏ��?spring-loaded允许您添�?修改/删除/字段/�Ҏ��构造函数。注释类�?�Ҏ��/字段/构造函��C��可以修改和可以添�?删除/修改值的枚�D�c�d��?br />
有什么好�?

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

��目地址

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

�W�一步：下蝲文�g
http://repo.spring.io/release/org/springframework/springloaded/1.2.5.RELEASE/springloaded-1.2.5.RELEASE.jar

�W�二步：配置jvm启动参数

eclipse

eclipse�Q�run as --> run configurations --> arguments -->> VM arguments
-javaagent:E:\repository\org\springframework\spring-load\springloaded-1.2.5.RELEASE.jar
-noverify -Dspringloaded=verbose
详细描述�Q?br />-javaagent: 配置java代理使用下蝲后的jar包�\�?br />-noverify: ��用字节码验�?br />-Dspringloaded=verbose 昄��springloaded时的详细信息

java命��o启动

java -javaagent:E:\repository\org\springframework\spring-load\springloaded-1.2.5.RELEASE.jar -noverify Test  �c�M��

java jar包动态替�?/h4>

1.打成runnable Jar

2.命��o启动�Q?/h5>

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

/**  * �c�Test.java的实现描�q�ͼ�TODO �c�d��现描�q?  * @author Administrator 2016�q?�?�?下午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");          }  }

改变�?/p>

/**  * �c�Test.java的实现描�q�ͼ�TODO �c�d��现描�q?  * @author Administrator 2016�q?�?�?下午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�Q�实���在window下无�?手上无linux机器待测�?/code>





1

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�Q�现在已发展成一个庞大体�p�R��比如security、mvc�{��?br />如此一来，不同模块或者与外部�q�行集成�Ӟ��依赖处理���需要各自对应版本号�?br />比如�Q�较新spring与较老的quartz�Q�它们集成就会遇到问题，�l�搭建和升��带来不便�?br />
因此Spring IO Platform应运而生�Q�只要项目中引入了它�Q�外部集成时依赖关系无需版本�?br />
<dependency>
 <groupId>org.springframeworkgroupId>
 <artifactId>spring-coreartifactId> 
dependency>

Spring IO Platform只是一个pom文�g�Q�记录了spring与其他开源项目对应的版本�?br />省去了版本号�Q�也���q����M��处理依赖时的问题�Q�因为Spring IO Platform中有最优的版本�?img src ="http://www.aygfsteel.com/paulwong/aggbug/427986.html" width = "1" height = "1" />

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


Spring面试问答Top 25
paulwong — Thu, 30 Apr 2015 05:29:00 GMT
     摘要: 问题清单�Q�什么是Spring框架�Q�Spring框架有哪些主要模块？使用Spring框架有什么好处？什么是控制反�{�Q�IOC�Q�？什么是依赖注入�Q�请解释下Spring中的IOC�Q�BeanFactory和ApplicationContext有什么区别？���Spring配置��C��的应用中共有几种�Ҏ���Q�什么基于XML的配�|�？什么基Java的配�|�？怎样用注解的方式配置Spring�Q�描�q�Spring Bean的生命周...  阅读全文

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


paulwong — Wed, 25 Feb 2015 08:34:00 GMT
ConcurrentMapCacheManager可以作�ؓ一�U�缓存方案，但不能设�|�过期，最大缓存条目等�Q�需�q�行攚w���?br />

     pom.xml中加入依赖包

             <dependency>
            <groupId>com.google.guavagroupId>
            <artifactId>guavaartifactId>
            <version>18.0version>
        dependency>
     

     
     攚w��CacheManager�Q�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>
     

     

     
     通过注释�q�行使用

     /*
 * 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)//清空所有缓�?/span>
    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加过期策�?br />http://stackoverflow.com/questions/8181768/can-i-set-a-ttl-for-cacheable

�l�合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的管理通常是由容器来做�Q�但如果是在PAAS环境下，服务器不能做变更�Q�则需要由WEB应用来做处理HTTP SESSION。同��P��如果是分布式的环境下�Q�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 发表评论


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
自定义注释就是一个标讎ͼ�一个信息收集器�Q�如果配合SPRING的AOP使用�Q�可以记录用��L��操作行�ؓ�?br />


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();



}





值对�?br />
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";

    }

    



}




保存��x��据库

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�Q�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
一大�LSpring Data相关包：
Spring Data Dijkstra SR1 发布�Q�该版本包含如下模块�?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 用户升���Q�因为包含重要的 bug 修复�?/p>

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 发表评论