Spring Boot是Spring的一个子项目，它让创建独立运行（通过java -jar）的、产品级别的Spring应用变得简单：

1. 支持创建独立运行于JVM中的Spring程序
2. 内嵌Tomcat、Jetty或者Undertow，不需要部署War包
3. 简化Maven的POM配置
4. 在任何可能的情况下，自动配置Spring
5. 提供产品级特性，包括性能度量、健康检测、外部化配置
6. 不需要任何代码生成或者XML配置

1. 支持Java 9，至少要求Java 8
2. 基于 Spring 5 构建，Spring 的新特性均可以在 Spring Boot 2.0 中使用
3. 为各种组件的响应式编程提供了自动化配置，如：Reactive Spring Data、Reactive Spring Security 等
4. 支持 Spring MVC 的非阻塞式替代方案 WebFlux 以及嵌入式 Netty Server
5. 对 HTTP/2 的支持
6. 更灵活的属性绑定API，不通过

   @ConfigurationProperties

   注解就能实现配置内容读取和使用
7. Spring Security 整合的简化
8. Gradle 插件增强，要求Gradle版本4.4+
9. Starter整合的第三方组件版本升级：
   1. Tomcat 升级至 9.0，Servlet版本4.0
   2. Jetty 升级至 9.4，Servlet版本3.1
   3. Flyway 升级至 5
   4. Hibernate 升级至 5.2
   5. Thymeleaf 升级至 3

本章我们创建一个简单的基于Spring Boot的Web应用。

首先设置父项目：

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.1.6.RELEASE</version>
</parent> 

然后添加Web的Starter依赖：

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

只需要这一个依赖就可以了，开发Spring MVC项目所需要的繁杂依赖项不需要手工指定，均使用spring-boot-starter-web的传递依赖即可。

最后配置一下Maven插件，打包为可执行JAR：

<build>
	<plugins>
		<plugin>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-maven-plugin</artifactId>
		</plugin>
	</plugins>
</build> 

package cc.gmem.study.spring;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
// 让Spring Boot猜测应该怎么样配置Spring（基于添加的依赖）
@EnableAutoConfiguration
public class SampleController {

    @RequestMapping( "/" )
    @ResponseBody
    String home() {
        return "Hello World!";
    }

    public static void main( String[] args ) throws Exception {
        System.getProperties().put( "server.port", 9090 );
        SpringApplication.run( SampleController.class, args );
    }
}

运行此程序，然后打开浏览器访问http://localhost:9090，即可访问。

<project>
    <!-- 
        继承基础配置：
        1、使用JDK 1.6作为默认编译级别
        2、使用UTF-8作为源码的编码方式
    -->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.6.RELEASE</version>
    </parent>
    <!-- 可以定制的配置 -->
    <properties>
        <java.version>1.8</java.version>
        <!-- 如果有多个main函数入口，需要指定一个start-class才能进行可执行JAR打包 -->
        <start-class>cc.gmem.study.spring.boot.HelloApp</start-class>
    </properties>
    <!-- Web应用典型依赖，包括了对Spring MVC和Tomcat的依赖 -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
 
    <!-- 打包为可执行的JAR -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>
 
</project>

如果parent构件已经存在，可以这样引入基础配置：

<dependencyManagement>
     <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>1.5.6.RELEASE</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

plugins {
    id 'org.springframework.boot' version '1.5.6.RELEASE'
    id 'java'
}


jar {
    baseName = 'myproject'
    version =  '0.0.1-SNAPSHOT'
}

repositories {
    jcenter()
}

dependencies {
    compile("org.springframework.boot:spring-boot-starter-web")
    testCompile("org.springframework.boot:spring-boot-starter-test")
}

所谓Starter，就是一个依赖描述符，你可以包含它们，避免手工逐个配置依赖项。上面我们已经使用了两种Starter。常用的Starter如下表：

尽管你可以通过

SpringApplication.run()

@Configuration

你可以使用

@Import

你也可以使用

@ComponentScan

如果要引入额外的XML配置，可以使用

@ImportResource

Spring Boot的自动配置机制，尝试根据当前项目的依赖，自动判断如何配置Spring上下文、运行容器、数据库。例如，如果HSQLDB位于类路径下，Spring Boot会自动配置一个内存数据库。

要启用自动配置，可以在主配置类上添加

@EnableAutoConfiguration

@SpringBootApplication

如果要查看哪些自动配置被启用，为何被启用，可以为应用程序传入参数

--debug

你可以明确的禁用某种自动配置：

@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class Configuration {
}

注意：自动配置可以被渐进的替代。例如，当你手工配置了数据源后，Spring Boot就不会自动配置HSQLDB。

此注解等价于@Configuration, @EnableAutoConfiguration,@ComponentScan的组合。其中@ComponentScan为：

@ComponentScan(excludeFilters = {
		@Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
		@Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })

由于没有为@ComponentScan指定basePackage，因此默认扫描当前类所在包及其子包。

可以通过@ComponentScan来查找Bean，或者在配置类的方法中使用@Bean。@Component, @Service, @Repository, @Controller等注解都是支持的。

要为Bean注入字段，可以使用@Autowired,@Inject等注解。

很多IDE，包括Eclipse、IDEA都提供了对Spring Boot应用程序的支持。

通过命令行运行的示例：

java -Xdebug -Xrunjdwp:server=y,transport=dt_socket,address=8000,suspend=n -jar boot-study.jar

通过Maven运行的示例：

export MAVEN_OPTS=-Xmx1024m -XX:MaxPermSize=128M
mvn spring-boot:run

通过Gradle运行的示例：

gradle bootRun

Spring Boot仅仅是简单的Java应用程序，JVM的热交换机制直接可以使用。但是JVM热交换有所限制，更加完整的解决方案是JRebel或者Spring Load。模块spring-boot-devtools也提供了快速的应用重启机制。

有多种实现方式，推荐使用spring-boot-devtools模块，因为它提供了额外的开发时特性——快速重启、LiveReload。DevTools的工作方式是监控类路径变化，这意味着你需要触发项目构建，在IDEA中可以调用Make Project触发（或者开启自动构建）。静态内容的变化不会导致应用重启，但是会导致LiveReload。

Spring Boot支持的模板技术大部分支持禁用缓存的功能，这样模板被修改后可以立即被感知到。使用spring-boot-devtools的情况下，模板自动重新载入。

大部分IDE支持代码热替换，因此你对类进行非结构性的改变时，构建后Java类会自动更新。

Spring Loaded允许方法签名改变后的类仍然能够重新载入。

spring-boot-devtools提供了自动的重启功能，其速度比JRebel、Spring Loaded慢，但是比冷启动快的多。

spring-boot-devtools的快速重启功能依赖于ClassLoader，打包好的第三方库，使用Base加载器加载，而正在开发的那些类则使用restart加载器加载。当快速重启发生后，之前的restart加载器被丢弃，新的restart加载器被创建。

此模块提供一些开发时特性，要启用DevTools，引入：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-devtools</artifactId>
    <version>1.5.6.RELEASE</version>
    <optional>true</optional>
</dependency>

DevTools在生产环境下会自动禁用，生产环境的判断依据是：

1. 以java -jar启动Spring Boot应用
2. 或者，使用了特殊的ClassLoader 

模板引擎具有缓存功能、Spring MVC也在HTTP头中添加了缓存字段。DevTools通过配置属性，禁用了这些功能。

默认情况下，使用了DevTools的应用会在类路径发生变化时自动重启，注意模板、静态资源不会触发重启。具体来说，下列位置的资源不会触发重启：

/META-INF/maven, /META-INF/resources ,/resources ,/static ,/public和/templates

如果需要显式指定那些资源不会触发重启，配置下面的属性：

# 自己指定不触发的资源
spring.devtools.restart.exclude=static/**,public/**
# 在默认不触发资源目录列表的基础上，额外增加
spring.devtools.restart.additional-exclude=

如果需要额外指定会触发重启的资源，配置下面的属性：

spring.devtools.restart.additional-exclude=

如果你使用某种持续的自动编译、产生输出的IDE，并且期望在这些输出发生变化时，触发重启，配置下面的属性：

spring.devtools.restart.trigger-file= 

要禁用DevTools的重启功能，配置下面的属性：

spring.devtools.restart.enabled=false

配置下面的属性以确定哪些JAR包由restart加载器加载：

# 下面的JAR由Base加载器加载
restart.exclude.companycommonlibs=/mycorp-common-[\\w-]+\.jar
# 下面的JAR由restart加载器加载
restart.include.projectcommon=/mycorp-myproj-[\\w-]+\.jar

DevTools包含了一个内嵌的LiveReload服务器，可以用来在资源发生变化时触发浏览器刷新。各大浏览器均有LiveReload扩展。

如果要禁用LiveReload服务器，配置：

spring.devtools.livereload.enabled=false 

此类提供了一些便捷方法，用于Spring应用的自举。最简单的用法：

SpringApplication.run(MyConfiguration.class, args);

可以使用链式调用进行定制化：

new SpringApplicationBuilder()
        .sources(Parent.class)
        .child(Application.class)
        .bannerMode(Banner.Mode.OFF)
        .run(args); 

启动后，控制台默认打印INFO级别的日志。

如果应用自举失败，已经注册的FailureAnalyzer会打印相关的信息，Spring Boot提供了很多FailureAnalyzer实现。 

如果FailureAnalyzer没有提供有价值的信息，你可以设置应用程序参数

--debug

你可以在类路径下放置一个banner.txt文件，或者设置banner.location来指定任意文件。你还可以在类路径下添加banner.png|gif|jpg等图片，这些图片会被转换为ASCII（透明的PNG背景被转换为黑色），打印在文本Banner之前。

除了ContextRefreshedEvent，SpringApplication会发布很多额外的事件：

SpringApplication会自动尝试创建合适的ApplicationContext实现类。默认的：

1. 如果当前应用是Web应用，创建AnnotationConfigEmbeddedWebApplicationContext
2. 否则创建AnnotationConfigApplicationContext

你可以调用setWebEnvironment()来强制指定是否Web应用。

你可以注入此类型，以访问传递给SpringApplication.run的参数。

Environment对象是配置信息的容器。

Spring Boot允许你把配置信息外部化，这样同一套代码就可以很容易的在不同环境下运行。

你可以使用YAML 、环境变量、命令行参数来指定配置。

使用

@Value

@Component
public class Bean {
    @Value("${name}")
    private String name;

}

如果类路径下的application.properties文件中有name这个键，或者命令行指定了--name参数，则会被注入到上述Bean的属性中。

Spring使用PropertySource来定位配置属性，它会从以下位置寻找（优先级从高到低）：

1. 当使用DevTools时，DevTools全局设置，位于~/.spring-boot-devtools.properties
2. 位于测试用例上的@TestPropertySource注解
3. 位于测试用例上的@SpringBootTest#properties注解
4. 命令行参数。例如 --server.port=9090
5. 来自SPRING_APPLICATION_JSON中的属性，这是内联在环境变量或者系统属性中的一个JSON
6. ServletConfig初始化参数
7. ServletContext初始化参数
8. 来自java:comp/env的JNDI属性
9. 系统属性System.getProperties()
10. OS环境变量
11. RandomValuePropertySource中的random.*属性
12. 位于应用JAR包外部的application-{profile}.properties文件（或者YAML），针对特定profile
13. 位于应用JAR包内部的application-{profile}.properties文件（或者YAML），针对特定profile
14. 位于应用JAR包外部的application.properties文件（或者YAML）
15. 位于应用JAR包内部的application.properties文件（或者YAML）
16. @Configuration类上的@PropertySource注解
17. 缺省属性，来自SpringApplication.setDefaultProperties

其中application.properties的搜索位置包括（优先级从高到低）：

1. 当前目录的/config子目录
2. 当前目录
3. 类路径下的/config包
4. 类路径根目录

如果你不想使用上述默认属性文件名称，可以指定命令行参数：

--spring.config.location=classpath:/default.properties,classpath:/override.properties

你可以针对不同运行环境，为Spring Boot应用定义多个Profile。Environment包含了若干内置Profile，且默认激活（如果你没有激活其它）default这个Profile。

针对特定Profile的属性定义在application-{profile}.properties文件中。

通过设置spring.profiles.active属性，可以改变当前活动Profile。例如：

spring.profiles.active=dev,hsqldb

在属性文件中，你可以通过占位符引用先前定义的属性：

app.name=MyApp
app.description=${app.name} is a Spring Boot application

你可以在属性文件中引用Maven项目属性：

spring.profiles.active=@environment@
app.encoding=@project.build.sourceEncoding@
app.java.version=@java.version@

配合Maven Profile：

<profile>
    <id>pro</id>
    <properties>
        <environment>pro</environment>
    </properties>
</profile>

则运行

mvn package -Ppro

Spring Boot支持使用Java Util Logging、Log4J2、Logback这几种日志实现。如果你使用Starters，则默认使用Logback。要定制日志配置，使用以下配置文件：

你可以使用Slf4J提供的日志API。

可以在application.properties中配置对应的属性：

# 设置根日志级别
logging.level.root=DEBUG
# 设置日志级别
logging.level.cc.gmem=DEBUG
# 配置基于文件的日志
logging.file=${java.io.tmpdir}/application.log
# 配置日志输出格式
logging.pattern.console= "%d{yyyy-MM-dd HH:mm:ss} - %msg%n"
logging.pattern.file= "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"

Spring MVC框架允许你创建特殊的@Controller、@RestController以处理入站的HTTP请求，具体处理逻辑由注解了@RequestMapping的方法负责。

执行以下自动配置：

1. 包含ContentNegotiatingViewResolver 、BeanNameViewResolver 这两个Bean
2. 支持包括WebJars在内的静态资源
3. 自动注册Converter、GenericConverter、Formatter
4. 支持HttpMessageConverters
5. 自动注册MessageCodesResolver
6. 支持静态index.html
7. 支持定制Favicon
8. 自动使用ConfigurableWebBindingInitializer 

如果你仅仅想添加额外的拦截器、formatters、view controllers，可以在WebMvcConfigurerAdapter的子类上加@Configuration注解，但是不使用@EnableWebMvc注解。

如果你希望使用自己实现的RequestMappingHandlerMapping、RequestMappingHandlerAdapter 、ExceptionHandlerExceptionResolver ，声明一个WebMvcRegistrationsAdapter，提供这些组件。

如果你希望对Spring MVC进行完全的控制，在主配置类上添加@EnableWebMvc注解。

如果需要自定义消息转换器，声明HttpMessageConverters类型的Bean即可：

import org.springframework.boot.autoconfigure.web.HttpMessageConverters;
// ...
@Bean
public HttpMessageConverters customConverters() {
    HttpMessageConverter<?> additional = ...
    HttpMessageConverter<?> another = ...
    return new HttpMessageConverters(additional, another);
}

当基于JacksonJSON来编解码JSON时，你可能需要定制JsonSerializer、JsonDeserializer。

结合Spring Boot使用时，如果要注册定制的编解码器，需要在编解码器类（或者其外部类）上声明注解：

@JsonComponent
public class JsonCodecs {
    public static class Serializer extends JsonSerializer {}
    public static class Deserializer extends JsonDeserializer {}
}

默认情况下，Spring Boot从类路径、ServletContext的根目录下寻找：

1. /static
2. /public
3. /resources
4. /META-INF/resources 

这几个目录，并将其作为静态内容看待，你可以设置spring.resources.static-locations以修改静态目录。 这些静态内容默认映射URL为/**，你可以设置下面的属性以修改：

# 重新定位URL
spring.mvc.static-path-pattern=/resources/** 

除了以目录方式组织的静态内容，Spring Boot还支持WebJars。任何/webjars/**目录下的JAR，如果符合WebJar格式，将会被作为静态资源使用。

你可以在静态文件根目录中放置一个favicon.ico文件。

Spring Boot支持FreeMarker、Groovy、Thymeleaf、Mustache这几种模板引擎的自动配置。

JSP也可以使用。

Spring Boot默认提供了一个/error映射，来处理所有错误，并且注册为Servlet容器的全局错误页面。此错误页面的默认行为：

1. 对于浏览器客户端：以HTML格式显示一个页面。要定制此页面，可以配置一个映射到/error的View
2. 对于机器客户端：返回一个JSON响应，包含错误码、详细错误信息。此JSON响应对应的Java类为ErrorAttributes，你可以注册一个ErrorAttributes的子类型Bean，改变响应内容
   你还可以针对特定的控制器、异常类型，定制此JSON：
   

   // 针对和FooController在同一包中的所有控制器
   @ControllerAdvice(basePackageClasses = FooController.class)
   public class FooControllerAdvice extends ResponseEntityExceptionHandler {
       // 针对YourException
       @ExceptionHandler(YourException.class)
       @ResponseBody
       ResponseEntity<?> handleControllerException(HttpServletRequest request, Throwable ex) {
           HttpStatus status = getStatus(request);
           // CustomErrorType的JSON展示会代替ErrorAttributes写到响应中
           return new ResponseEntity<>(new CustomErrorType(status.value(), ex.getMessage()), status);
       }
   
       private HttpStatus getStatus(HttpServletRequest request) {
           Integer statusCode = (Integer) request.getAttribute("javax.servlet.error.status_code");
           if (statusCode == null) {
               return HttpStatus.INTERNAL_SERVER_ERROR;Media Source
           }
           return HttpStatus.valueOf(statusCode);
       }
   
   }Environment

要完成替换上述默认行为，可以注册一个ErrorController类型的Bean。

如果希望针对不同的HTTP状态码定制错误页面，添加一个文件到/error目录下。错误页面可以是静态HTML或者某种被支持的模板。 

例如，要对404定制错误页面，可以创建src/main/resources/public/error/404.html。要对所有5xx定制错误页面，可以在前面的目录中创建5xx.ftl。

跨源资源共享（Cross-origin resource sharing）是被浏览器广泛实现的W3C规范，允许你指定一个灵活的策略，允许哪些跨Domain请求被发送。使用CORS可以避免使用IFRAME、JSONP等变通技术。

Spring MVC 4.2开始对CORS进行了开箱即用的支持。你可以在控制器方法上使用@CrossOrigin注解。或者配置全局性的CORS策略：

@Configuration
public class MyConfiguration {
    @Bean
    public WebMvcConfigurer corsConfigurer() {
        return new WebMvcConfigurerAdapter() {
            @Override
            public void addCorsMappings(CorsRegistry registry) {
                registry.addMapping("/api/**");
            }
        };
    }
}

如果你喜欢基于JAX-RS编程模型创建REST端点，你可以使用Jersey、 Apache CXF等框架。要集成到Spring你只需要把它们的Servlet、Filter注册为@Bean。

Jersey 2.x对Spring集成提供了支持，Spring Boot可以进行自动配置，你需要依赖spring-boot-starter-jersey这个Starter并且注册ResourceConfig类型的Bean：

@Component
@ApplicationPath("/api")  // 默认情况下Jersey Servlet被映射到/*，此注解用于定制映射路径
public class JerseyConfig extends ResourceConfig {
    public JerseyConfig() {
        register(Endpoint.class);
    }
}
// 所有注册的Endpoint，必须是@Component，且包含HTTP资源注解（例如GET)
@Component
@Path("/hello")
public class Endpoint {
    @GET
    public String message() {
        return "Hello";
    }
}

要进行更定制化的配置，实现任意数量的ResourceConfigCustomizer类型的Bean。

默认情况下，Jersey在一个ServletRegistrationBean类型的@Bean中初始化其Servlet。此Servlet默认是延迟加载的，你可以配置属性spring.jersey.servlet.load-on-startup让其立即加载。 你也可以配置spring.jersey.type=filter，这样一个ServletFilter会代替上述Servlet。

添加Maven依赖：

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <dependency>
    <groupId>org.apache.cxf</groupId>
    <artifactId>cxf-spring-boot-starter-jaxrs</artifactId>
    <version>3.3.1</version>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <!-- 对JSON的支持 -->
  <dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-jaxrs</artifactId>
    <version>1.9.13</version>
  </dependency>
  <dependency>
    <groupId>org.codehaus.jackson</groupId>
    <artifactId>jackson-xc</artifactId>
    <version>1.9.13</version>
  </dependency> 
</dependencies>

RESTful资源接口示例，一般直接将Service层作为RESTful资源的接口：

import java.util.Collection;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;

import com.javacodegeeks.examples.jaxrs.model.Student;

// 将此类标识为根资源
@Path("students")
// 指定请求、响应的MIME类型
@Consumes("application/json;charset=UTF-8")
@Produces(MediaType.APPLICATION_JSON)
public interface StudentService {
  
  // 动词，此外支持@POST, @UPDATE，@DELETE
  @GET
  public Collection<Student> getAllStudents();
  
  @Path("{id}")
  @GET
  // 返回值类型javax.ws.rs.core.Response，是HTTP响应的抽象
  public Response getById(@PathParam("id") Long id);

}

在Spring属性中配置CXF：

# 默认/services
cxf.path=/studentservice
# 让CXF自动扫描带有JAX-RS注解的类
cxf.jaxrs.classes-scan=true
cxf.jaxrs.classes-scan-packages=cc.gmem.springboot.jaxrs

现在你可以通过URL：http://localhost:8080/studentservice/students来访问 StudentService暴露的RESTful服务了。

Spring Boot支持内嵌的Tomcat、Jetty或者Undertow。通过合适的Starter你就可以得到自动化的配置。内嵌服务器默认监听端口8080。

当使用内嵌Servlet容器时，标准的Servlet组件（Servlet、Filter、Listener）既可以注册为Spring Beans，也可以自动被扫描。要启用自动扫描，使用@ServletComponentScan注解，@WebServlet、@WebFilter、@WebListener可以被自动扫描。

如果应用中仅仅有一个Servlet，它会默认被映射到 /，如果有多个Servlet，其Bean名称被作为URL前缀。Filter默认映射到/*。

如果自动化配置不能满足需要，你可以实现自己的ServletRegistrationBean、FilterRegistrationBean或者ServletListenerRegistrationBean。

要定制Servlet容器的运行参数，可以使用配置属性，通常定义在application.properties文件中。通用的配置属性包括：

# 密钥数据库的位置
server.ssl.key-store:classpath:keystore.jks
# 密钥数据库的密码
server.ssl.key-store-password:kurento
# 密钥数据库的类型
server.ssl.keyStoreType:JKS
# 使用的密钥
server.ssl.keyAlias:kurento-selfsigned

这是一种特化的WebApplicationContext，在自举时它会寻找一个EmbeddedServletContainerFactory实现类，通常是TomcatEmbeddedServletContainerFactory、JettyEmbeddedServletContainerFactory或者UndertowEmbeddedServletContainerFactory，以创建Servlet容器。

Spring Boot支持基于内嵌容器的自动化WebSockets配置，包含对spring-boot-starter-websocket的依赖即可。 

要启用任务调度支持，只需要在应用程序入口添加

@EnableScheduling

@EnableScheduling
public class App {}


// 每5秒调度执行一次
@Scheduled( fixedRate = 5000 )
@Scheduled( cron = "*/5 * * * * * *" )
// 每次执行完毕后，延迟5秒再次执行
@Scheduled( fixedDelay = 5000 )
public synchronized void cleanup() {
}

引入依赖：

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

在主程序上使用注解来启用缓存支持：

import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class CacheApplication {} 

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>6.0.6</version>
        </dependency>

        <!-- 使用Log4j2 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
            <version>RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-logging</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j2</artifactId>
            <version>RELEASE</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>2.5.0</version>
        </dependency>

        <!-- Spring Boot 缓存支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
            <version>RELEASE</version>
        </dependency>
        <!-- Spring Boot data-jpa支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
            <version>RELEASE</version>
        </dependency>
    </dependencies>
</project>

spring.jpa.show-sql=true
spring.jpa.hibernate.ddl-auto=none

spring.datasource.url=jdbc:mysql://10.255.223.241:3306/digital
spring.datasource.username=digital
spring.datasource.password=digital
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

package cc.gmem.study.sb.entity;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table( name = "media" )
public class Media {

    @Id
    private Long mediaId;

    @Column
    private Long saleId;

    @Column
    private String title;

    @Column( name = "is_bn" )
    private String isbn;

    @Column( name = "shelf_status" )
    private boolean onShelf;
}

package cc.gmem.study.sb.repo;


import cc.gmem.study.sb.entity.Media;
import org.springframework.cache.annotation.*;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.query.Param;

/**
 * JpaRepository<EntityClass,IdType>，继承了：
 *      PagingAndSortingRepository 支持分页和排序
 *          CrudRepository 支持常规增删改查
 *              Repository 标识接口
 */

/* 类级别的缓存公共设置 */
@CacheConfig( cacheNames = "media" )
public interface MediaRepository extends JpaRepository<Media, Long> {

    // 指定一个JPA查询
    @Query( "SELECT m FROM Media m WHERE m.isbn=:isbn AND m.onShelf=true" )
    /**
     * 将函数调用结果放入缓存，优先从缓存中查找，如果找不到才真正调用函数
     * key 指定SpEL表达式作为缓存键，p0表示第一个入参，result表示返回值
     * keyGenerator 不能和key同时使用，指定一个org.springframework.cache.interceptor.KeyGenerator实现类
     * sync 多个线程同时调用此函数时，是否串行化。当底层操作非常耗时时可以设置为true
     * condition 指定SpEL，仅当（在函数调用前的）求值结果为true时才会缓存
     * unless 指定SpEL，仅当（在函数调用后的）求值结果为false时才会缓存，可以引用result变量
     * cacheManager 指定使用的缓存管理器，@EnableCaching会自动注册可用的缓存管理器，查找缓存实现的顺序为：
     *      GenericJCache EhCache 2.x Hazelcast Infinispan Redis Guava Simple
     *      可以使用spring.cache.type强制指定
     * cacheResolver 指定使用的缓存解析器
     */
    @Cacheable( key = "#p0", sync = false, condition = "#p0.length()==13", unless = "#result == null" )
    Media findByIsbn( @Param( "isbn" ) String isbn );

    @Override
    /**
     * 调用此函数时导致缓存清除
     * allEntries 清除所有缓存
     * beforeInvocation 在调用函数前还是后执行清除
     */
    @CacheEvict( key = "#p0", allEntries = false, beforeInvocation = false )
    void deleteById( Long mediaId );

    @Override
    // 下面的注解总是调用函数并缓存其结果
    @CachePut( key = "#p0.isbn" )
    // 可以同时存储多个缓存
    @Caching(
        put = {
            // 可以引用result
            @CachePut(value = "media", key = "#result.username", condition = "#result != null"),
            @CachePut(value = "media", key = "#result.id", condition = "#result != null")
        }
    )
    Media save( Media media );
}

package cc.gmem.study.sb.service;


import cc.gmem.study.sb.entity.Media;
import cc.gmem.study.sb.repo.MediaRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.transaction.Transactional;

@Service
@Transactional
public class MediaService {

    @Autowired
    private MediaRepository repo;

    public Media findUserByIsbn( String isbn ) {
        return repo.findByIsbn( isbn );
    }
}

package cc.gmem.study.sb;

import cc.gmem.study.sb.entity.Media;
import cc.gmem.study.sb.service.MediaService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.domain.EntityScan;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.ApplicationContext;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;

@SpringBootApplication
// 启用Spring基于注解的缓存管理
@EnableCaching
// 从何处扫描JPA实体类
@EntityScan( basePackages = { "cc.gmem.study.sb.entity" } )
// 从何处查找Repository接口的子接口，并自动生成实现类
@EnableJpaRepositories( basePackages = "cc.gmem.study.sb.repo" )
public class JPACacheApplication {

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

    public static void main( String[] args ) {
        ApplicationContext ctx = SpringApplication.run( JPACacheApplication.class, args );
        MediaService ms = ctx.getBean( MediaService.class );
        Media m = ms.findUserByIsbn( "9787547227961" );
        LOGGER.debug( m.getTitle() );
        m = ms.findUserByIsbn( "9787547227961" );
        LOGGER.debug( m.getTitle() );
    }
}

org.springframework.boot.diagnostics应该调整到debug级别， org.springframework应该调整到warn级别，这样可以看到更多有价值的日志。

The post Spring Boot学习笔记 appeared first on 绿色记忆.

Spring 4.x引入了新的模块spring-websocket，对WebSocket提供了全面的支持，Spring的WebSocket实现遵循JSR-356（Java WebSocket API），并且添加了一些额外特性。

绝大部分现代浏览器均支持WebSocket，包括IE 10+。对于不支持WebSocket的浏览器，Spring允许基于 SockJS协议作为备选传输方案。

与REST那种大量URL + HTTP方法来区分对象和操作的风格完全不同，WebSocket仅仅使用单个URL。WebSocket更加和传统的MOM类似，它是异步的、 事件驱动的基于消息的架构。

Spring 4 引入了新的模块spring-messaging，抽象出了Message、MessageChannel、MessageHandler等消息架构的基础概念。此模块包含了一些注解，用于将消息映射到方法（类似于Spring MVC把URL映射到方法）。

WebSocket是在TCP之上很薄的一层封装，它仅仅是把比特流转换为消息（文本、二进制）流，解析消息的职责由应用程序负责。我们可以在WebSocket之上提供应用层子协议。

在WebSocket握手阶段，客户端和服务器可以基于Sec-WebSocket-Protocol头来协商子协议。Spring支持STOMP —— 一个简单的消息协议。

Spring提供了可以在很多WebSocket引擎中运行的API，支持的引擎包括Tomcat 7.0.47+, Jetty 9.1+, GlassFish 4.1+, WebLogic 12.1.3+等。

要创建一个WebSocket服务器，可以实现WebSocketHandler接口，或者继承TextWebSocketHandler或者BinaryWebSocketHandler类：

import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.TextMessage;

public class HelloHandler extends TextWebSocketHandler {
    // 接受消息的回调
    public void handleTextMessage(WebSocketSession session, TextMessage message) {
        // 发送消息
        session.sendMessage( new TextMessage( payload ) );
    }

}

每个WebSocketHandler， 处理单个URL。在一个WebSocket端口上可以有多个WebSocketHandler。要注册WebSocketHandler，可以：

import org.springframework.web.socket.config.annotation.EnableWebSocket;
import org.springframework.web.socket.config.annotation.WebSocketConfigurer;
import org.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(helloHander(), "/hello");
    }

    @Bean
    public WebSocketHandler helloHander() {
        return new HelloHander();
    }

}

也可以使用等价的XML配置：

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:websocket="http://www.springframework.org/schema/websocket"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/websocket
        http://www.springframework.org/schema/websocket/spring-websocket.xsd">

    <websocket:handlers>
        <websocket:mapping path="/hello" handler="helloHander"/>
    </websocket:handlers>

    <bean id="helloHander" class="cc.gmem.study.spring.ws.HelloHandler"/>

</beans>

通过HandshakeInterceptor可以对WebSocket最初基于HTTP的握手进行定制，此拦截器暴露beforeHandshake/afterHandshake方法，实现这些方法可以：

1. 阻止握手
2. 设置在WebSocketSession中可以使用的属性 

拦截器的注册方式为：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {

    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(new HelloHandler(), "/hello")
                // 添加拦截器
                .addInterceptors(new HttpSessionHandshakeInterceptor());
    }

}

等价的XML配置：

<websocket:handlers>
    <websocket:mapping path="/hello" handler="helloHandler"/>
    <websocket:handshake-interceptors>
        <bean class="org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor"/>
    </websocket:handshake-interceptors>
</websocket:handlers>

使用WebSocketHandlerDecorator来装饰WebSocketHandler，可以实现额外的行为。当基于Java-Config / XML来配置时，日志、异常处理这两个装饰器自动添加。

ExceptionWebSocketHandlerDecorator会捕获任何WebSocketHandler抛出的异常，并以1011状态码（服务器错误）关闭WebSocket会话。

WebSocket API可以和Spring MVC一起使用，DispatcherServlet同时负责WebSocket握手和普通HTTP请求的处理。

你也可以独立在其它HTTP服务环境中使用WebSocket API，可以借助WebSocketHttpRequestHandler集成WebSocketHandler到HTTP服务环境中。

每种底层Servlet引擎都暴露了一些配置属性，进行缓冲区大小、超时时间等参数的配置。

当使用Tomcat/WildFly/GlassFish时，你可以使用ServletServerContainerFactoryBean进行引擎配置：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Bean
    public ServletServerContainerFactoryBean createWebSocketContainer() {
        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
        // WebSocket消息缓冲区大小，如果客户端发来的消息较大，需要按需调整
        // 和libwebsockets配合时，客户端报错error on reading from skt : 104，即因为缓冲区不够大
        container.setMaxTextMessageBufferSize(8192);
        container.setMaxBinaryMessageBufferSize(8192);
        return container;
    }
}

当使用Jetty时，你需要提供一个WebSocketServerFactory，并传递给Spring的DefaultHandshakeHandler：

@Configuration
@EnableWebSocket
public class WebSocketConfig implements WebSocketConfigurer {
    @Override
    public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
        registry.addHandler(helloHandler(),"/hello")
               // 设置握手处理器
               .setHandshakeHandler(handshakeHandler());
    }

    @Bean
    public DefaultHandshakeHandler handshakeHandler() {

        WebSocketPolicy policy = new WebSocketPolicy(WebSocketBehavior.SERVER);
        policy.setInputBufferSize(8192);
        policy.setIdleTimeout(600000);

        return new DefaultHandshakeHandler(
                new JettyRequestUpgradeStrategy(new WebSocketServerFactory(policy)));
    }
}

从 Spring4.1.5开始，WebSocket/SockJS默认仅仅支持同源请求。不同策略下的行为如下：

1. 仅仅允许同源请求（默认）。在此模式下，如果启用SockJS，则IFrame的HTTP响应头X-Frame-Options被设置为SAMEORIGIN，JSONP被禁用
2. 允许指定列表的源，每个源必须以http或者https开头。在此模式下，如果启用SocketJS，IFrame、JSONP两种传输都被禁用
3. 设置为*。在此模式下，所有传输都可以使用

修改配置的代码：

@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    registry.addHandler(helloHandler(), "/hello").setAllowedOrigins("*");
}

WebSocket不受一些老旧的浏览器支持，并且某些网络代理阻止了WebSocket协议。因此Spring将SockJS作为备选实现，模拟WebSocket API。

要启用SockJS支持，调用：

@Override
public void registerWebSocketHandlers(WebSocketHandlerRegistry registry) {
    registry.addHandler(helloHandler(), "/hello").withSockJS();
}

// 等价XML配置 <websocket:sockjs/> 

为了防止代理服务器认为连接已经挂起，SockJS Protocol需要发送心跳消息。Spring提供配置参数

.withSockJS().setHeartbeatTime( )

HTTP流/长轮询这两种传输，要求连接打开时间比使用它的时间更长。在Servlet容器中，这依赖于Servlet 3的异步支持实现  —— 允许请求处理线程退出，之后由其它线程继续向响应中写入数据。

异步请求的问题在于，服务器不知道客户端是否已经断开，只有在后续继续写入响应时，才会抛出异常。不管怎么样，心跳还是能够最终发现断开的。

如果允许跨源请求，SockJS协议依赖CORS来支持跨站HTTP流/长轮询，因此CORS头会被自动添加，除非检测到响应头中指定了对应的CORS头。

配置suppressCors可以禁止自动添加CORS头。

SockJS期望的头包括：

1. Access-Control-Allow-Origin，基于Origin请求头初始化
2. Access-Control-Allow-Credentials总设置为true
3. Access-Control-Request-Headers从对应的请求头初始化
4. Access-Control-Allow-Methods传输机制所需要的HTTP方法
5. Access-Control-Max-Age设置为31536000（一年）

Spring实现了SockJS的Java客户端，允许你在服务器中使用SockJS，或者在压力测试中模拟大量客户端。

此客户端支持websocket/xhr-streaming/xhr-polling这三种传输。其中：

1. WebSocketTransport可以连同下面的实现使用：
   1. JSR-356的StandardWebSocketClient
   2. Jetty 9的JettyWebSocketClient
   3. Spring的任何WebSocketClient实现类
2. XhrTransport有两种实现：
   1. RestTemplateXhrTransport，基于Spring的RestTemplate
   2. JettyXhrTransport，基于Jetty的HttpClient

客户端代码示例：

List<Transport> transports = new ArrayList<>(2);
transports.add(new WebSocketTransport(new StandardWebSocketClient()));
transports.add(new RestTemplateXhrTransport());

SockJsClient sockJsClient = new SockJsClient(transports);
sockJsClient.doHandshake(new HelloHandler(), "ws://gmem.cc:8888/hello");

当模拟大量并发客户端时，底层HTTP客户端实现应该配有足够的资源，例如：

HttpClient jettyHttpClient = new HttpClient();
jettyHttpClient.setMaxConnectionsPerDestination(1000);
jettyHttpClient.setExecutor(new QueuedThreadPool(1000));

WebSocket协议定义了两种消息类型：文本和二进制数据，但是消息的内容没有定义。通常情况下，服务器和客户端能够协商使用一种子协议，来定义消息的结构，STOMP是一种常见的选择，其优势在于：

1. 浏览器中可以使用stomp.js
2. 不需要引入新的消息格式
3. 支持基于destination的消息路由
4. 能够与支持STOMP的MOM集成

STOMP是一种文本协议，最初设计供Ruby/Python/Perl之类的脚本语言使用，以连接到企业的消息代理。STOMP被设计用来处理常见的消息模式，可以基于任何双向可靠信道 —— 例如TCP、WebSocket ——传输。

尽管STOMP是基于文本的协议，但是它的载荷部分可以是二进制的。

STOMP是一种基于Frame的协议，其Frame设计理念源于HTTP。一个Frame的结构如下：

COMMAND
header1:value1
header2:value2

Body^@

客户端可以使用SEND或者SUBSCRIBE命令，可以发送、订阅消息。此时需要指定一个destination头。下面是两个示例：

SUBSCRIBE
id:sub-1
destination:/topic/price.stock.*

^@ 

SEND
destination:/queue/trade
content-type:application/json
content-length:44

{"action":"BUY","ticker":"MMM","shares",44}^@

STOMP服务器可以使用MESSAGE来广播消息到所有订阅者：

MESSAGE
message-id:nxahklf6-1
subscription:sub-1
destination:/topic/price.stock.MMM

{"ticker":"MMM","price":129.45}^@ 

当使用Spring的STOMP支持时，Spring的WebSocket应用相对客户端而言是STOMP代理。消息会被路由给@Controller下的消息处理方法或者一个简单内存消息代理处理。

你也可以配置Spring，让其与支持STOMP的消息中间件（例如RabbitMQ、ActiveMQ）一起工作，这样客户端就可以把消息发送消息中间件网络中。Spring负责维护到MOM的TCP连接、把消息中继到MOM、并且把监听到的消息下发给连接到Spring的那些客户端。

利用spring-messaging和spring-websocket模块，Spring能够支持STOMP over WS。

配置示例：

@Configuration
// 启用基于WebSocket的消息代理（使用某种子协议）
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        // 在/stomp暴露一个基于WebSocket/SockJS的STOMP端点
        registry.addEndpoint("/stomp").withSockJS();
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry config) {

        // 如果destination以/app开头，则消息路由给@Controller下的消息处理方法
        config.setApplicationDestinationPrefixes("/app");

        // 所有destination均由@Controller下的消息@MessageMapping方法处理
        config.setApplicationDestinationPrefixes("/");

        // 下面的两种开头的destination广播给所有其它客户端
        config.enableSimpleBroker("/topic", "/queue");
    }

}

@Controller
@MessageMapping("greeting")
public class GreetingController {
    @Inject 
    private SimpMessagingTemplate template; // 用于发送消息
    // 此消息处理方法处理/app/greeting/hello这一目标
    @MessageMapping("hello") {
    public String hello(String greeting) {
        String msg =  "[" + getTimestamp() + ": " + greeting;
        // 可以向任何地方发送消息
        this.template.convertAndSend("/topic/greetings", msg);
    }
}

等价XML配置：

<websocket:message-broker application-destination-prefix="/app">
    <websocket:stomp-endpoint path="/stomp">
        <websocket:sockjs/>
    </websocket:stomp-endpoint>
    <websocket:simple-broker prefix="/topic, /queue"/>
</websocket:message-broker>

消息目的地，默认的路径分隔好符是  / ，客户端发送时，目的地必须以 / 为第一个字符。除非包含多个路径分段，@MessageMapping的路径不需要包含 / 。

如果要使用MOM领域更加通用的点号分隔符，调用：

registry.setPathMatcher(new AntPathMatcher("."));

等价的XML配置为：

<websocket:message-broker application-destination-prefix="/app" path-matcher="pathMatcher">
</websocket:message-broker>
<bean id="pathMatcher" class="org.springframework.util.AntPathMatcher">
    <constructor-arg index="0" value="." />
</bean>

即使使用点号分隔符，客户端发送的目的地，也要以 / 开头。 

// 可以使用SockJS：
var socket = new SockJS("/stomp");
var client = Stomp.over(socket); 
// 或者直接使用WebSocket
var client = Stomp.over( new WebSocket( 'ws://172.21.0.1:9090/signal' ) );

// 心跳设置
client.heartbeat.outgoing = 20000;   // 每20秒发送一次心跳给服务器
client.heartbeat.incoming = 0;       // 不接受服务器发送来的心跳

// 调试设置
client.debug = function(str) {
    console.log(str);
};

// 连接
client.connect(login, passcode, connectCallback, errorCallback);
client.connect(headers, connectCallback, errorCallback);
function connectCallback( frame ){
}

// 发送消息，目的地、头、体
client.send("/queue/hello", {priority: 9}, "Hello, STOMP");

// 订阅消息
var subscription = client.subscribe("/topic/hello", callback);
function callback( message ){
    console.log( message.body );
}

// 带消息确认设置的订阅：客户端确认
var subscription = client.subscribe("/topic/hello", callback, {ack: 'client'});
function callback( message ){
    // 确认
    message.ack();
}

// 事务支持
var tx = client.begin();
// transaction头必须
client.send("/queue/hello", {transaction: tx.id}, "message in a transaction");
tx.commit();  // 提交事务
tx.abort();   // 撤销事务

或者直接使用WebSocket：

var socket = new WebSocket("/stomp");
var client = Stomp.over(socket);

WebSocketClient webSocketClient = new StandardWebSocketClient();
WebSocketStompClient stompClient = new WebSocketStompClient(webSocketClient);
stompClient.setMessageConverter(new StringMessageConverter());
stompClient.setTaskScheduler(taskScheduler); // 用于发送心跳

// 创建连接
String url = "ws://127.0.0.1:8080/endpoint";
StompSessionHandler sessionHandler = new StompSessionHandlerImpl();
class StompSessionHandlerImpl extends StompSessionHandlerAdapter {
    public void afterConnected(StompSession session, StompHeaders connectedHeaders) {
        // 连接成功后，此回调被调用
    }
}
stompClient.connect(url, sessionHandler);

// 发送消息
session.send("/topic/foo", "payload");
// 订阅消息
session.subscribe("/topic/foo", new StompFrameHandler() {
    public Type getPayloadType(StompHeaders headers) {
        return String.class;
    }
    public void handleFrame(StompHeaders headers, Object payload) {
        // 处理消息
    }
}); 

spring-messaging提供了以下抽象：

你可以在@Controller类的方法上添加@MessageMapping注解，这类方法可以映射某个/某些消息destination。

@MessageMapping对应的URL支持Ant风格的通配符，例如/foo*、/foo/**。路径变量也是支持的，例如/foo/{id}中的id可以通过注解了@DestinationVariable的方法参数访问到。

你可以为@MessageMapping方法注入很多种参数：

使用STOMP时，身份验证基于HTTP协议的机制进行。

尽管STOMP协议包含login、passcode头，但是它们通常在STOMP over TCP的情况下使用。Spring默认会忽略这些头，并且假设在HTTP升级到WebSocket之前已经完成身份验证。

如果需要基于STOMP头进行身份验证，可以进行如下配置：

@Configuration
@EnableWebSocketMessageBroker
public class AppConfig extends AbstractWebSocketMessageBrokerConfigurer {
  @Override
  public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.setInterceptors(new ChannelInterceptorAdapter() {
        @Override
        public Message<?> preSend(Message<?> message, MessageChannel channel) {
            StompHeaderAccessor accessor =  MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);
            if (StompCommand.CONNECT.equals(accessor.getCommand())) {
                String login = accessor.getNativeHeader( "login" ).get( 0 );
                Principal user = new PrincipalImpl( login );
                accessor.setUser(user);
            }
            return message;
        }
    });
  }
}

注意，不进行任何配置的情况下，你不能为@MessageMapping方法注入Principal对象，执行了上述配置则可以注入。其它备选的身份验证方式包括：

1. 子类化DefaultHandshakeHandler，覆盖determineUser方法，这样可以在WebSocket握手阶段确定用户。示例：
   

   registry.addEndpoint( "/signal" ).setHandshakeHandler( new DefaultHandshakeHandler() {
       @Override
       protected Principal determineUser( ServerHttpRequest request, WebSocketHandler wsHandler, Map<String, Object> attributes ) {
           Principal principal = request.getPrincipal();
           if ( principal == null ) {
               Collection<SimpleGrantedAuthority> authorities = new ArrayList<>();
               authorities.add( new SimpleGrantedAuthority( AuthoritiesConstants.ANONYMOUS ) );
               principal = new AnonymousAuthenticationToken( "WebsocketConfiguration", "anonymous", authorities );
           }
           return principal;
       }
   } );

2. 使用基于HTTP的身份验证，Spring会尝试从HttpServletRequest.getUserPrincipal中获得当前用户

默认情况下，Spring认为

/user/

客户端代码示例：

let client = Stomp.over( new WebSocket( 'ws://172.21.0.1:9090/signal' ) );
client.connect( {}, ( frame ) => {
    start();
} );
function start() {
    // 客户端订阅用户目的地，需要/user前缀
    client.subscribe( '/user/rtsp/preview/sdpanswer', function ( frame ) {
        console.log( frame.body );
    } );
    client.send( '/app/rtsp/preview/sdpoffer', {}, '1' );
}

服务器代码示例：

@Controller
@MessageMapping( "/rtsp/preview" )
public class RtspPreviewController {
    @MessageMapping( "/sdpoffer" )
    // 发送到用户目的地（仅仅发送给当前WebSocket会话对应的客户端），需要指定完整路径，/user前缀不需要
    @SendToUser( "/rtsp/preview/sdpanswer" )
    public String connect( String payload ) {
        return payload;
    }
}

关于@SendToUser需要注意，实际发送到的目的地是/user/{username}/rtsp/preview，Spring按照以下规则确定username：

1. 如果当前会话的Principal存在，则取Principal.getName()作为用户名
2. 否则，取会话标识符，会话标识符来自消息头中的simpSessionId字段

当允许同一个用户在多个浏览器中登陆时，要注意这个情况，如果Principal存放登陆名，客户端可能接收到不期望的消息。

配置示例：

@SpringBootApplication
// 两个注解都需要：
@EnableWebSocket
@EnableWebSocketMessageBroker
public class VideoSurveillanceApp extends AbstractWebSocketMessageBrokerConfigurer implements WebSocketConfigurer {
    public void registerWebSocketHandlers( WebSocketHandlerRegistry registry ) {
        // 下面的端点使用原始WebSocket
        registry.addHandler( helloHandler(), "/hello" );
    }
    public void registerStompEndpoints( StompEndpointRegistry registry ) {
        // 下面的端点使用STOMP
        registry.addEndpoint( "/signal" );
    }
}

The post Spring对WebSocket的支持 appeared first on 绿色记忆.

Spring 提供了JMS的集成，简化JMS的使用，提供的API封装类似于Spring的JDBC集成。

JMS的功能大体上分为两类——接收、发送消息。Spring提供了：

1. JmsTemplate来完成消息的发送、同步接收
2. 消息监听器容器（message listener containers）来异步的接收消息（事件驱动）

JmsTemplate是Spring的jms-core包的核心类，它封装了资源的创建、释放部分，简化收发消息的代码。

JmsTemplate类是线程安全的，除非需要不同的收发配置（QoS），整个系统可以仅仅使用单例的JmsTemplaet。

发送消息时，你可以提供一个MessageCreator回调来实现消息发送：

jmsTemplate.send( queueName, new MessageCreator() {
    @Override
    public Message createMessage( Session session ) throws JMSException {
        return session.createTextMessage( ... );
    }
} );

如果需要使用更加复杂的JMS API，可以调用下面的方法：

jmsTemplate.execute( new SessionCallback<Object>() {
    public Object doInJms( Session session ) throws JMSException {
        return null;
    }
} );
jmsTemplate.execute( new ProducerCallback<Object>() {
    public Object doInJms( Session session, MessageProducer producer ) throws JMSException {
        return null;
    }
} );

JMS API中有很多QoS设置项，例如优先级、TTL，这些都暴露为JmsTemplate的属性。你可以根据业务需要创建多个JmsTemplate。某些JMS实现在ConnectionFactory级别管理QoS设置，要明确指定使用JmsTemplate上的QoS选项，需要调用

jmsTemplate.setExplicitQosEnabled( true )

JmsTemplate集成了简单请求/应答模式的支持：

Message response = jmsTemplate.sendAndReceive( session -> {
    Message msg = session.createTextMessage();
    msg.setJMSReplyTo( "临时答复队列名称" );
    return msg;
} );

你需要为JmsTemplate提供一个ConnectionFactory的引用，后者属于JMS规范的一部分，任何JMS提供商都需要实现。ConnectionFactory是创建到MOM中间件连接的工厂。

标准的JMS API，在收发消息时需要使用很多中间对象：ConnectionFactory ⇨ Connection ⇨ Session ⇨ MessageProducer ⇨ send()。这些中间对象如果反复创建、销毁，会影响性能。Spring提供了一些具有缓存能力的ConnectionFactory实现：

Spring支持类似于EJB的消息驱动Bean的功能，该功能由消息监听容器实现，你可以用XML配置或者注解驱动的方式，指定POJO的方法会自动被调用以完成消息的处理。

消息监听容器负责从JMS队列/主题监听消息，并负责管理多线程的消息消费、事务管理、资源获取/是否。

消息监听容器的实现类主要有：

<!--
  container-type = default表示DefaultMessageListenerContainer
  concurrency = 1 表示每一个jms:listener对应的Session/Consumer个数（也就是线程数？）
  destination-type = durableTopic 表示目标是持久化订阅，这种情况下 client-id + subscription是必须的
  cache为缓存方式：
      none：不缓存
      connection：为每个监听器线程缓存Connection对象
      session：为每个监听器线程缓存Connection、Session对象
      consumer：为每个监听器线程缓存Connection、Session、Consumer对象
      auto：默认值，通常取值consumer，但是指定了外部事务管理器时，取值none
      transaction-manager：事务管理器
-->
<jms:listener-container container-type="default" connection-factory="cf" acknowledge="auto" concurrency="1"
                        destination-type="durableTopic" client-id="APP" cache="auto">
    <jms:listener destination="监听的主题" ref="你提供的回调Bean" method="你提供的回调方法" subscription="持久化订阅名称"/>
</jms:listener-container>

<!-- 不使用JMS名字空间时的类似配置 -->
<bean id="jmsContainer" class="org.springframework.jms.listener.DefaultMessageListenerContainer">
    <property name="messageListener" ref="messageListener" />
</bean>
<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter">
    <constructor-arg>
        <bean class="你提供的回调Bean"/>
    </constructor-arg>
    <property name="defaultListenerMethod" value="你提供的回调方法"/>
    <!-- 禁止消息类型转换 -->
    <property name="messageConverter">
        <null/>
    </property>
</bean>

编程式配置DMLC：

@Configuration
@EnableJms
public class AppConfig {

    @Bean
    public DefaultJmsListenerContainerFactory jmsListenerContainerFactory() {
        DefaultJmsListenerContainerFactory factory =
                new DefaultJmsListenerContainerFactory();
        factory.setConnectionFactory(connectionFactory());
        factory.setDestinationResolver(destinationResolver());
        factory.setConcurrency("3-10");
        return factory;
    }
}

监听器配置：

@Component
public class MyService {
    // 使用@Header注入单个消息头、使用@Headers注入所有消息头，接收参数必须为Map
    // 使用@Payload可以明确指定接收载荷的参数
    // Message、Session可以被注入
    @JmsListener(destination = "queue")
    public void processOrder(String data, @Header("ordertype") String orderType) {
    }
    
    
    @JmsListener(destination = "myDestination")
    @SendTo("status") // 可以指定应答队列
    public OrderStatus processOrder(Order order) {
        return status;
    }
} 

这个组件允许你把任意POJO作为MDP（消息驱动POJO）使用，而不需要实现MessageListener接口：

public class MessageListenerAdapter implements MessageListener, SessionAwareMessageListener<Message>{
    public MessageListenerAdapter(Object delegate) {
         setDelegate(delegate);
    }
}

构造方法参数delegate可以是任何对象， MessageListenerAdapter假设它实现以下接口：

public interface MessageDelegate {
    // 根据消息类型的不同，自动选择调用的方法
    void handleMessage(String message);
    void handleMessage(Map message);
    void handleMessage(byte[] message);
    void handleMessage(Serializable message);
}

delegate也可以提供其它形式的方法，但是需要指定defaultListenerMethod配置。 

回调方法可以具有参数，对应接收到的消息，也可以具有返回值，对应发送到原始消息Reply-To字段指定的，或者listener默认配置的应答队列的应答消息。

参数类型可以是各种各样的，但是需要messageConverter的配合。

Spring提供了针对单个ConnectionFactory的JmsTransactionManager，事务资源是绑定到线程的。JmsTransactionManager会自动检测到事务资源并打开之。

在JEE环境下，ConnectionFactory可能对Connection、Session进行缓存，资源因而是跨事务重用的。在独立运行环境下，使用Spring的SingleConnectionFactory会导致Connection共享，而每个事务使用独立的Session。

JmsTemplate也可以使用JtaTransactionManager + 支持XA的ConnectionFactory，以支持分布式事务。

在独立运行环境下，你需要设置JmsTemplate的sessionAcknowledgeMode、sessionTransacted来告知Spring是否使用Jms事务。当联用PlatformTransactionManager、JmsTemplate时，JmsTemplate总是提供事务性的Session对象

JmsTemplate的

convertAndSend()

receiveAndConvert()

如果要对转换后，发送前对JMS消息对象进行处理，可以使用MessagePostProcessor：

jmsTemplate.convertAndSend( queue, map, new MessagePostProcessor() {
    public Message postProcessMessage( Message message ) throws JMSException {
        message.setIntProperty( "AccountID", 1000 );
        message.setJMSCorrelationID( "123-00001" );
        return message;
    }
} );

通过JMX查看ActiveMQ队列状态，发现消息已经被消费。打开WARN级别的Spring日志，发现报方法找不到。配置的回调方法：

public void onP2PMessage( Message message ) throws Exception {
}

此问题的原因是，回调方法的参数必须是JMS消息的载荷。因此，对于TextMessage，回调参数类型应该是String。 

The post Spring对JMS的支持 appeared first on 绿色记忆.

hibernateDialect=org.hibernate.dialect.MySQL5Dialect
#启用了log4jdbc支持
jdbcDriver=net.sf.log4jdbc.DriverSpy
jdbcDriverUrl=jdbc:log4jdbc:mysql://192.168.0.201:3306/initpemsdb1.1.1
jdbcUserName=root
jdbcPassword=root

<?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:p="http://www.springframework.org/schema/p"
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:util="http://www.springframework.org/schema/util" 
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx" 
    xmlns:task="http://www.springframework.org/schema/task" 
    xmlns:cache="http://www.springframework.org/schema/cache"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
        http://www.springframework.org/schema/task  http://www.springframework.org/schema/task/spring-task-3.0.xsd
        http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache-3.1.xsd
    ">
    <!-- 定义属性，在后面的配置中可以使用#{appCfg.xxx}引用 -->
    <util:properties id="appCfg" location="classpath:applicationConfig.properties" />
    <!-- 包扫描配置 -->
    <context:component-scan base-package="cc.gmem.demo">
        <!-- 去除Java Config类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
        <!-- 去除Spring MVC类 -->
        <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller" />
        <!-- 匹配AspectJ Pattern的类被去除 -->
        <context:exclude-filter type="aspectj" expression="cc.gmem.demo.aop.web.*" />
    </context:component-scan>
    <!-- 启用注解支持 -->
    <context:annotation-config />
    <!-- 支持@Configurable注解 -->
    <context:spring-configured />
    <!--  启用注解方式的事务：基于AspectJ织入 -->
    <tx:annotation-driven transaction-manager="txManager" mode="aspectj" />
    <!--  启用注解方式的缓存配置：基于AspectJ织入 -->
    <cache:annotation-driven cache-manager="cacheManager" mode="aspectj" />
    <!--  启用注解方式的任务执行(例如@Async)：基于AspectJ织入 -->
    <task:annotation-driven executor="taskExecutor" mode="aspectj" />
    
    <!--  任务调度器配置，pool-size为线程池大小，限制了同时最多被调度的任务 -->
    <task:scheduler pool-size="100" id="scheduler" />
    <!-- 任务计划列表，支持固定频率、固定延迟、Cron表达式等 -->
    <task:scheduled-tasks scheduler="scheduler">
        <task:scheduled fixed-rate="120000" method="run" ref="hibernateStatisticsMonitor" />
    </task:scheduled-tasks>
    <!-- 任务执行器，用于异步执行任务 -->
    <task:executor id="taskExecutor" keep-alive="3600" pool-size="10-100" queue-capacity="10000" rejection-policy="CALLER_RUNS" />
    <!-- 引入其它Spring配置文件 -->
    <import resource="report-and-etl.xml" />  
    <!-- Hibernate配置  -->
    <bean id="dataSource" class="org.logicalcobwebs.proxool.ProxoolDataSource">
        <property name="alias" value="connectionPool" />
        <property name="driver" value="#{appCfg.jdbcDriver}" />
        <property name="driverUrl" value="#{appCfg.jdbcDriverUrl}" />
        <property name="user" value="#{appCfg.jdbcUserName}" />
        <property name="password" value="#{appCfg.jdbcPassword}" />
        <property name="statistics" value="10s" />
        <property name="minimumConnectionCount" value="10" />
        <property name="maximumConnectionCount" value="100" />
        <property name="simultaneousBuildThrottle" value="10" />
        <property name="maximumActiveTime" value="3600000" />
    </bean>
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate" autowire="byName" />
    <bean id="nativeJdbcExtractor" class="org.springframework.jdbc.support.nativejdbc.CommonsDbcpNativeJdbcExtractor" lazy-init="true" />
    <bean id="sessionFactory" p:dataSource-ref="dataSource" class="cc.gmem.demo.hibernate.AnnotationSessionFactoryBean" depends-on="appCfg" >
        <property name="packagesToScan">
            <list>
                <value>cc.gmem.demo.**.domain</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <value>
                hibernate.dialect=#{appCfg.hibernateDialect}
                hibernate.jdbc.batch_size=30
                hibernate.show_sql=false
                hibernate.format_sql=true
                hibernate.generate_statistics=true
                hibernate.transaction.factory_class=org.hibernate.transaction.JDBCTransactionFactory
                hibernate.current_session_context_class=org.springframework.orm.hibernate3.SpringSessionContext
                hibernate.query.factory_class=org.hibernate.hql.ast.ASTQueryTranslatorFactory
                hibernate.hbm2ddl.auto=update
                #启用二级缓存
                hibernate.cache.use_second_level_cache=true
                hibernate.cache.use_query_cache=true
                hibernate.cache.region.factory_class=org.hibernate.cache.SingletonEhCacheRegionFactory
            </value>
        </property>
    </bean>
    <!-- Spring缓存配置 -->
    <bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
        <property name="cacheManager" ref="ehcache" />
    </bean>
    <bean id="ehcache" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
        <property name="configLocation">
            <value>classpath:ehcache.xml</value>
        </property>
        <property name="shared" value="true" />
    </bean>
    <bean id="hibernateStatisticsMonitor" class="cc.gmem.demo.hibernate.HibernateStatisticsMonitor" />
    <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager" p:sessionFactory-ref="sessionFactory" />
    <!-- Velocity引擎配置 -->
    <bean id="velocityEngine" class="org.apache.velocity.app.VelocityEngine">
        <constructor-arg type="java.util.Properties">
            <value>
                <![CDATA[
                #{T(org.apache.velocity.runtime.RuntimeConstants).RUNTIME_LOG_LOGSYSTEM_CLASS}=org.apache.velocity.runtime.log.Log4JLogChute
                runtime.log.logsystem.log4j.logger=velocityLogger
                #{T(org.apache.velocity.runtime.RuntimeConstants).INPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).OUTPUT_ENCODING}=UTF-8
                #{T(org.apache.velocity.runtime.RuntimeConstants).VM_PERM_ALLOW_INLINE}=true
                #{T(org.apache.velocity.runtime.RuntimeConstants).RESOURCE_LOADER}=class
                #{T(org.apache.velocity.runtime.RuntimeConstants).PARSER_POOL_SIZE}=100
                class.resource.loader.class=org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
                ]]>
            </value>
        </constructor-arg>
    </bean>
    <!--国际化支持-->
    <bean id="messageSource" class="org.springframework.context.support.ReloadableResourceBundleMessageSource">
         <property name="basenames">
             <list>
                 <value>classpath:message.gmemdemo</value>
             </list>
         </property>
         <property name="defaultEncoding" value="UTF-8" />
         <property name="cacheSeconds" value="5" />
    </bean>
    <!--Jackson JSON -->
    <bean id="objectMapper" class="com.fasterxml.jackson.databind.ObjectMapper" autowire="byType" />
    <!-- Spring类型转换服务，特别是用于时间日期格式转换 -->
    <bean id="conversionService" class="org.springframework.format.support.FormattingConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="net.greenmemory.spring.converter.DateTimeConvertor">
                    <constructor-arg>
                        <array>
                            <value>yyyy-MM-dd</value>
                            <value>yyyy-MM-dd HH:mm:ss</value>
                            <value>yyyy-MM-dd HH:mm:ss.SSS</value>
                       </array>
                    </constructor-arg>
                </bean>
            </set>
       </property>
       <property name="formatters">
           <set>
               <bean class="org.springframework.format.datetime.DateFormatter">
                   <constructor-arg>
                       <value>yyyy-MM-dd</value>
                   </constructor-arg>
               </bean>
           </set>
       </property>
       <property name="formatterRegistrars">
           <set>
           </set>
       </property>
    </bean>
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<beans 
    xmlns="http://www.springframework.org/schema/beans" 
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd
        http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.1.xsd
        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    ">
    <context:component-scan base-package="cc.gmem.demo.**.ctrl">
        <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />
    </context:component-scan>
    <context:component-scan base-package="cc.gmem.demo.aop.web" />

    <context:annotation-config />

    <mvc:annotation-driven>
        <mvc:message-converters>
            <bean class="org.springframework.http.converter.json.jacksonjson.MappingJackson2HttpMessageConverter">
                <property name="objectMapper" ref="objectMapper" />
            </bean>
        </mvc:message-converters>
    </mvc:annotation-driven>

    <mvc:interceptors>
        <bean id="openSessionInViewInterceptor" class="org.springframework.orm.hibernate3.support.OpenSessionInViewInterceptor">
            <property name="sessionFactory" ref="sessionFactory" />
        </bean>
            <mvc:interceptor>     
            <mvc:mapping path="/home/*" /> 
            <!-- 自定义MVC拦截器 -->
            <bean class="cc.gmem.demo.spring.LogonInterceptor" /> 
        </mvc:interceptor>  
        
    </mvc:interceptors>

    <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
        <property name="order" value="0" />
    </bean>

    <mvc:resources mapping="/css/**" location="/css/" />
    <mvc:resources mapping="/icons/**" location="/icons/" />
    <mvc:resources mapping="/images/**" location="/images/" />
    <mvc:resources mapping="/themes/**" location="/themes/" />
    <mvc:resources mapping="/js/**" location="/js/" />
</beans>

<?xml version="1.0" encoding="UTF-8"?>
<ehcache>
    <diskStore path="D:/Temp/ehcache" />
    <defaultCache eternal="false" />
    <cache name="entityCache" eternal="false" maxElementsInMemory="1000" timeToIdleSeconds="120" timeToLiveSeconds="3600"
        overflowToDisk="true" memoryStoreEvictionPolicy="LFU" />
</ehcache>

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <context-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </context-param>
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cc.gmem.demo.spring.SpringBeanDefinitionRegistrar</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextClass</param-name>
            <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
        </init-param>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>cc.gmem.demo.spring.SpringMVCBeanDefinitionRegistrar</param-value>
        </init-param>
    </servlet>
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

    <servlet-mapping>
        <servlet-name>adminServlet</servlet-name>
        <url-pattern>/proxool</url-pattern>
    </servlet-mapping>

    <session-config>
        <session-timeout>60</session-timeout>
    </session-config>

    <error-page>
        <error-code>404</error-code>
        <location>/WEB-INF/jsp/error-404.jsp</location>
    </error-page>
    <error-page>
        <error-code>401</error-code>
        <location>/WEB-INF/jsp/error-401.jsp</location>
    </error-page>
    <error-page>
        <error-code>500</error-code>
        <location>/WEB-INF/jsp/error-500.jsp</location>
    </error-page>
     <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
</web-app>

@Configuration
/* XML-based bean definitions */
@ImportResource ( "classpath:applicationContext.xml" )
public class SpringBeanDefinitionRegistrar
{

    /* Auto injected spring context */
    @SuppressWarnings ( "unused" )
    @Inject
    private ApplicationContext applicationContext;

    /* Programmatic bean definition */
    @Bean ( name = "helper" )
    public Helper helper()
    {
        Helper helper = new Helper();
        return helper;
    }

}

@Configuration
@ImportResource ( "classpath:spring-mvc.xml" )
public class SpringMVCBeanDefinitionRegistrar
{

}

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <spring.version>3.1.2.RELEASE</spring.version>
    <hibernate.version>3.6.10.Mod</hibernate.version>
    <aspectj.version>1.6.11</aspectj.version>
    <jackson.version>2.0.4</jackson.version>
</properties>
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-core</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-orm</artifactId>
        <version>${spring.version}</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring.version}</version>
    </dependency>

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-core</artifactId>
        <version>${hibernate.version}</version>
    </dependency>

    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectj.version}</version>
    </dependency>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>${aspectj.version}</version>
    </dependency>

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-core</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>${jackson.version}</version>
    </dependency>
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-annotations</artifactId>
        <version>${jackson.version}</version>
    </dependency>

    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>servlet-api</artifactId>
        <version>2.4</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>2.0</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>1.2</version>
    </dependency>
    <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>1.1.2</version>
        <scope>provided</scope>
    </dependency>
    <dependency>
        <groupId>javax.el</groupId>
        <artifactId>el-api</artifactId>
        <version>2.2</version>
        <scope>provided</scope>
    </dependency>

    <dependency>
        <groupId>proxool</groupId>
        <artifactId>proxool</artifactId>
        <version>0.9.1</version>
    </dependency>

    <dependency>
        <groupId>org.javassist</groupId>
        <artifactId>javassist</artifactId>
        <version>3.15.0-GA</version>
    </dependency>

    <dependency>
        <groupId>net.sf.log4jdbc</groupId>
        <artifactId>log4jdbc3</artifactId>
        <version>1.2-ext-3</version>
    </dependency>
    <dependency>
        <groupId>com.sqlinform</groupId>
        <artifactId>sqlinform</artifactId>
        <version>0.0.1</version>
    </dependency>

    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>jsr250-api</artifactId>
        <version>1.0</version>
    </dependency>
    <dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>

    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.1</version>
    </dependency>

    <dependency>
        <groupId>cglib</groupId>
        <artifactId>cglib</artifactId>
        <version>2.2.2</version>
    </dependency>

    <dependency>
        <groupId>org.apache.poi</groupId>
        <artifactId>poi</artifactId>
        <version>3.9</version>
    </dependency>
    
    <dependency>
        <groupId>opensymphony</groupId>
        <artifactId>quartz-all</artifactId>
        <version>1.6.3</version>
    </dependency>
</dependencies>

<plugin>
    <groupId>org.codehaus.mojo</groupId>
    <artifactId>aspectj-maven-plugin</artifactId>
    <version>1.4</version>
    <executions>
        <execution>
            <id>compile</id>
            <configuration>
                <XnoInline>true</XnoInline>
                <forceAjcCompile>true</forceAjcCompile>
                <showWeaveInfo>true</showWeaveInfo>
                <source>1.5</source>
                <target>1.5</target>
                <encoding>UTF-8</encoding>
                <verbose>true</verbose>
                <outxml>true</outxml>
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
            <goals>
                <goal>compile</goal>
            </goals>
        </execution>
    </executions>
</plugin>

The post Spring配置：集成Hibernate、JacksonJSON、AspectJ等框架 appeared first on 绿色记忆.

package sparknet.wnet.saic.intf.spring;

import java.io.IOException;
import java.util.Properties;

import javax.inject.Inject;
import javax.sql.DataSource;

import net.greenmemory.breeze.persist.OracleProxoolDataSource;
import net.greenmemory.commons.db.QueryRunner;
import net.greenmemory.commons.lang.NumberUtils;
import net.greenmemory.spring.core.io.ClassPathResource;

import org.hibernate.SessionFactory;
import org.springframework.aop.framework.autoproxy.InfrastructureAdvisorAutoProxyCreator;
import org.springframework.beans.factory.BeanInitializationException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.ComponentScan.Filter;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.context.annotation.FilterType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.orm.hibernate3.HibernateTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.AnnotationTransactionAttributeSource;
import org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor;
import org.springframework.transaction.interceptor.TransactionInterceptor;

import cc.gmem.tools.hibernatetools.spring.Hibernate3LocalSessionFactoryBean;

@Configuration
@ComponentScan (
        basePackages = { "cc.gmem.saic", "cc.gmem.intf" },
        excludeFilters = { @Filter ( type = FilterType.ANNOTATION, value = Configuration.class ) } )
@EnableAspectJAutoProxy
public class BeanDefinitionRegistrar
{

    @Inject
    private ApplicationContext applicationContext;

    @Bean ( name = "cfg" )
    public Properties getAppConfig()
    {
        Properties props = new Properties();
        try
        {
            props.load( new ClassPathResource( "wsi.properties" ).getInputStream() );
        }
        catch ( IOException e )
        {
            throw new BeanInitializationException( e.getMessage(), e );
        }
        return props;
    }

    @Bean ( name = "dataSource" )
    public DataSource getDataSource()
    {
        OracleProxoolDataSource dataSource = new OracleProxoolDataSource();
        dataSource.setAlias( getAppConfig().getProperty( "jdbc.alias" ) );
        dataSource.setDriver( getAppConfig().getProperty( "jdbc.driverClass" ) );
        dataSource.setDriverUrl( getAppConfig().getProperty( "jdbc.url" ) );
        dataSource.setUser( getAppConfig().getProperty( "jdbc.user" ) );
        dataSource.setPassword( getAppConfig().getProperty( "jdbc.password" ) );
        dataSource.setMinimumConnectionCount( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.minimumConnectionCount" ), 10 ) );
        dataSource.setMaximumConnectionCount( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.maximumConnectionCount" ), 100 ) );
        dataSource.setSimultaneousBuildThrottle( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.simultaneousBuildThrottle" ), 50 ) );
        dataSource.setMaximumActiveTime( NumberUtils.toInt( getAppConfig().getProperty( "jdbc.maximumActiveTime" ), 1200000 ) );
        dataSource.setEncrypted( false );
        dataSource.init();
        return dataSource;
    }

    @Bean ( name = "sessionFactory" )
    public SessionFactory getSessionFactory() throws Exception
    {
        Hibernate3LocalSessionFactoryBean bean = new Hibernate3LocalSessionFactoryBean();
        bean.setApplicationContext( applicationContext );
        bean.setDataSource( getDataSource() );
        bean.setMappingResources( new String[] { "wnetJhInterface.hbm.xml" } );
        bean.setAutoRegister( true );
        Properties hibernateProperties = new Properties();
        hibernateProperties.setProperty( "hibernate.dialect", "org.hibernate.dialect.Oracle10gDialect" );
        hibernateProperties.setProperty( "hibernate.jdbc.batch_size", "100" );
        hibernateProperties.setProperty( "hibernate.default_entity_mode", "dom4j" );
        hibernateProperties.setProperty( "hibernate.transaction.factory_class", "org.hibernate.transaction.JDBCTransactionFactory" );
        hibernateProperties.setProperty( "hibernate.current_session_context_class", "org.springframework.orm.hibernate3.SpringSessionContext" );
        bean.setHibernateProperties( hibernateProperties );
        bean.afterPropertiesSet();
        return bean.getObject();
    }

    @Bean ( name = "txManager" )
    public PlatformTransactionManager getTransactionManager() throws Exception
    {
        HibernateTransactionManager txMgr = new HibernateTransactionManager();
        txMgr.setSessionFactory( getSessionFactory() );
        return txMgr;
    }

    @Bean ( name = "jdbcTemplate" )
    public JdbcTemplate getJdbcTemplate()
    {
        return new JdbcTemplate( getDataSource() );
    }

    @Bean ( name = "queryRunner" )
    public QueryRunner getQueryRunner()
    {
        return new QueryRunner( getDataSource() );
    }

    @Bean
    public AnnotationTransactionAttributeSource transactionAttributeSource()
    {
        return new AnnotationTransactionAttributeSource();
    }

    @Bean
    public TransactionInterceptor transactionInterceptor() throws Exception
    {
        return new TransactionInterceptor( getTransactionManager(), transactionAttributeSource() );
    }

    @Bean
    public TransactionAttributeSourceAdvisor internalTransactionAdvisor() throws Exception
    {
        return new TransactionAttributeSourceAdvisor( transactionInterceptor() );
    }

    @Bean
    public InfrastructureAdvisorAutoProxyCreator internalAutoProxyCreator()
    {
        return new InfrastructureAdvisorAutoProxyCreator();
    }
}

ApplicationContext ctx = new AnnotationConfigApplicationContext(BeanDefinitionRegistrar.class);
DataSource ds= ctx.getBean(DataSource.class);

The post 基于JavaConfig方式的Spring+Hibernate集成 appeared first on 绿色记忆.

1. AspectJ编译器能识别任何普通的Java代码，可以使用ajc编译.java文件
2. 织入方式：
   

   源代码织入	织入器作为编译器的一部分，处理源代码，支持经典语法和注解语法。生成的字节码符合JVM规范，需要使用ajc代替javac
   字节码织入	传递给织入器的是字节码。使用这种方式时，包含编译普通Java类、编译切面，织入3个步骤。
   加载时织入	传递给织入器的是Java类字节码、切面类，以及aop.xml配置文件。

3. AspectJ暴露的连接点。只能在这些连接点上应用通知：
   

   	暴露的连接点	代码表现
   方法	执行 Execution	方法体：该连接点环绕整个方法体的执行过程。这也是Spring AOP唯一支持的接入点类型。通知被织入方法体 切入点语法：execution(方法签名)
   	调用 Call	方法调用：该接入点发生在方法被调用时。通知被织入调用者代码处 切入点语法：call(方法签名)
   构造器	执行 Execution	对象构造逻辑：该连接点环绕整个构造器的执行过程 切入点语法：execution(构造器签名)
   	调用 Call	对象构造调用 切入点语法：call(构造器签名)
   字段访问	读访问 Read access	读取类或对象的字段 切入点语法：get(字段签名)
   	写访问 Read access	写入类或对象的字段 切入点语法：set(字段签名)
   异常处理	处理器 Handler	处理异常的catch块 切入点语法：handler(类型签名)
   初始化	类初始化 Class initialization	类加载，包括静态成员初始化部分 切入点语法：staticinitialization(类型签名)
   	对象初始化 Object initialization	在构造器中的对象初始化。包含：从一个父构造器返回，到当前构造器执行完成的部分（不包括调用父构造器的部分） 切入点语法：initialization(构造器签名) Spring的@Configurable即为此例 。下面的例子解释了连接点的范围： public class SavingsAccount extends Account { private boolean isOverdraft; private int minimumBalance; //构造器1 public SavingsAccount( int accountNumber, boolean isOverdraft ) { super( accountNumber ); //对象初始化连接点：构造器1，2 this.isOverdraft = isOverdraft; } //构造器2 public SavingsAccount( int accountNumber ) { //对象初始化连接点：构造器2 this( accountNumber, false ); //对象初始化连接点：构造器2 this.minimumBalance = 25; } }
   	对象预初始化 pre-initialization	在构造器中的对象初始化之前：用的很少，从当前构造器调用，到父构造器调用结束为止 切入点语法：preinitialization(构造器签名)
   通知	执行 Execution	通知的执行：环绕某个通知的整个执行。可以对通知进行通知 切入点语法：adviceexecution()

4. AspectJ切入点声明语法
   

   /**
    * 切入点声明语法，包含5个部分：
    * 访问标识符：例如 public
    * 关键字：pointcut
    * 切入点名称()
    * 切入点类型：例如execution、call，参考：第3点
    * 切入点签名：根据切入点类型不同，可能是类型签名、方法签名、字段签名
    */
   public pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));

   AspectJ支持仅有切入点名称，而没有类型和签名的切入点，通常使用在抽象切面中。
   AspectJ支持匿名切入点，作为通知签名的一部分存在。
   AspectJ支持使用 !、 && 、|| 来作为切入点的运算符

5. AspectJ通知定义语法：由通知声明、切入点定义、通知体三部分组成
   

   组成	说明
   整体语法形式： [@AdviceName("通知的名称")] [返回值] 通知类型([上下文信息]) [returning|throwing] [throws 通知抛出的异常] : 切入点定义([上下文信息]) { 通知体 }
   通知声明	通知类型可以是：before, after 或 around，其中around需要声明返回值通知声明可以指定通知体可用的上下文信息，包括：执行对象通知声明可以指定通知体可能抛出的异常
   切入点定义	位于冒号之后，任何匹配切入点定义的连接点上都会执行本通知
   通知体	可以访问一系列特殊的变量或关键字，例如：proceed、thisJoinPoint、thisJoinPointStaticPart、 thisEnclosingJoinPointStaticPart

6. AspectJ支持的通知类型
   

   通知类型	说明
   Before advice	在连接点执行之前执行，如果抛出异常，那么连接点不被执行
   After advice	在连接点执行之后执行，根据连接点的执行结果，具有3个子类型：After (finally)：在连接点执行之后执行，不论其结果，通知声明语法：after()After returning：在连接点执行成功后执行，通知声明语法：after() returning(<ReturnType returnObject>)After throwing：在连接点执行失败后执行，通知声明语法：after() throwing(<ExceptionType exceptionObject>)
   Around advice	环绕连接点的执行过程，具有修改连接点执行上下文的能力，可以用来： 在连接点之前/之后添加额外的逻辑，例如性能分析 跳过原先逻辑还执行备选的逻辑，例如缓存。只要不调用proceed()，即跳过 使用try-catch包裹原先逻辑，提供异常处理策略，例如事务管理

通配符用于匹配一系列的连接点。

这里的类型泛指：类、接口、注解、切面、基本类型
基本类型签名示例：

基于注解的类型签名示例：
由于Java不支持注解的继承，所有注解名后不会出现加号。注意注解必须运行时可见（

RetentionPolicy.RUNTIME

基于泛型的类型签名示例：

联合类型签名示例：

构造器签名与方法类似，但是：

1. 由于构造器没有返回值，因此不得在签名中指定返回值
2. 由于构造器不能为静态，故不得添加static关键字
3. 由于构造器没有名称，必须使用new作为其名称部分

基本方法签名示例：

基于注解的方法签名示例：

注意注解必须运行时可见（

RetentionPolicy.RUNTIME

字段签名中，使用get表示读字段，set表示写字段：

字段签名示例：

注意注解必须运行时可见（

RetentionPolicy.RUNTIME

AspectJ提供几种切入点指示器（designators），配合上面所述的切入点签名，即组成切入点。
切入点通过两种方式与连接点进行匹配：

1. 类型限定的切入点：直接映射到某个类型的连接点，参考AspectJ暴露的连接点一节中的“切入点语法”部分
2. 无类型的切入点：根据指定的信息，来选择特定的连接点。这些信息可以是：连接点上下文的运行时类型、控制流，或者此法作用域（lexical scope）

匹配：指定类型和签名的连接点
Spring：仅支持execution类型
静态确定：是

不去限定连接点的类型，还是通过若干种规则去匹配多种连接点。

Spring虽然仅仅支持execution一种类型的连接点，但是却支持多种方式来选择它们

基于控制流的切入点
这一类的切入点匹配 处于其他切入点的控制流之中 的连接点。这句话比较难以理解，以贷款业务为例，假设Account.debit()方法调用Account.getBalance()进行余额查询，那么，可以说：getBalance在debit的控制流之中。类似的，字段访问、异常处理，也可以处于某个切入点的控制流之中。
Spring不支持这一类切入点，不能静态确定（需要运行时判断）
包含两种切入点类型：cflow、cflowbelow，后者不包括启动控制流的连接点本身

下面以事务管理的场景为例，来说明控制流切入点的用法：

package cc.gmem.aj.cflow;
public class Account
{
    //两个方法均具有事务注解，但是，我们需要在“最外层”来启动事务
    //需要忽略内层的事务注解
    @Transactional
    public void debit()
    {
        getBalance();
    }
    @Transactional
    public void getBalance()
    {
    }
}

public aspect TransactionAspect
{
    //匹配所有标注了@Transactional的方法执行
    private pointcut transacted() : execution(@Transactional * *(..));
    //匹配这样的@Transactional方法：不在@Transactional方法的所确定的控制流的内部
    private pointcut topLevelTransacted() : transacted() && !cflowbelow(transacted());

    Object around() : topLevelTransacted() {
        System.out.println( "启动事务" );
        Object ret = proceed();
        System.out.println( "结束事务" );
        return ret;
    }
}

基于词法结构的切入点
匹配：在指定类型、方法、构造器内的连接点
Spring：支持within()，不支持withincode()
可以静态确定
包含两种切入点类型：within(类型签名)、withincode(构造器签名|方法签名)

执行对象切入点
根据运行时对象类型来选择连接点。并且，可以收集执行对象——双重功能。

包含两种类型：this(<Type or ObjectIdentifier>)、target(<Type or ObjectIdentifier>)，前者匹配this引用为指定类型的连接点；后者匹配方法调用target为指定类型的连接点。

该类切入点不支持类型通配，也不支持泛型。该类切入点不会匹配任何静态方法的执行连接点。

注意区别：
execution(* Account.*(..)) 匹配Account类的任何静态、成员方法
execution(* *.*(..))  && this(Account)：匹配Account及其子类的任何成员方法
参数切入点
该类切入点根据连接点的参数对象的运行时类型来匹配。并且，可以收集匹配的参数对象。
Spring支持此类切入点。无法静态确定。
所谓参数对象，根据连接点不同，含义也不同：

1. 对于方法、构造器连接点，参数对象即方法参数
2. 对于异常处理连接点，参数对象即被处理的异常
3. 对于字段写入连接点，参数对象即被写入的值

该类切入点的形式为：args(Type or ObjectIdentifier, ..)

基于注解的切入点

注意：注解本身被标注的注解影响AOP行为：

1. @Retention(RetentionPolicy.RUNTIME)：只有设置为运行时保留，才能在运行时进行匹配性判断
2. @Inherited：只有标注了此注解，子编程元素（类、方法）才能继承父元素上标注的注解

AspectJ支持根据类型、方法、字段所标注的注解来匹配连接点

条件检查切入点
此类切入点在连接点上的一些条件检查。通常和其它切入点联合使用

本段代码示意经典的AspectJ语法：

package cc.gmem.aj;

//切面的声明
public aspect SecurityAspect
{

    private Authenticator auth = new Authenticator();

    //切入点的声明
    pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));
    //通知声明：针对secureAccess切入点的before通知
    before() : secureAccess() {
        System.out.println( "Checking and authenticating user" );
        auth.doAuthenticate();
    }
}

本段代码示意基于注解的AspectJ语法：
基于注解的语法，可以作为普通Java类编译，并且使用LTW（加载时织入）机制，在类被加载到JVM中时进行织入。

package cc.gmem.aj;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;

@Aspect
public class SecurityAspect
{

    private Authenticator auth = new Authenticator();

    @Pointcut ( "execution(* cc.gmem.aj.MessageCommunicator.deliver(..))" )
    public void secureAccess()
    {
    }

    @Before ( "secureAccess()" )
    public void secure()
    {
        System.out.println( "Checking and authenticating user" );
        auth .doAuthenticate();
    }
}

环绕通知的简单例子，注意proceed()的使用：

public aspect SecurityAspect
{
    private Authenticator auth = new Authenticator();

    pointcut secureAccess(): execution(* MessageCommunicator.deliver(..));

    Object around() : secureAccess() {
        long start = System.nanoTime();
        //伪关键字proceed，用于继续执行被通知的目标方法
        Object ret = proceed();
        //thisJoinPointStaticPart是通知可用变量之一，可以获取连接点的静态信息，例如方法名
        System.out.println( thisJoinPointStaticPart.getSignature() + " took " + ( end - start ) + " nanoseconds" );
        return ret;
    }
}

上下文收集的简单例子：

package cc.gmem.aj;

import java.sql.Connection;
import java.sql.SQLException;

public aspect ConnectionAspect
{
    //匹配Connection的任何抛出SQLException方法的调用
    //被调用（target）的Connection对象收集为connection变量。
    pointcut connectionOperation( Connection connection )//独立定义的切入点，必须使用这种参数声明来传递上下文信息给通知
        : call(* Connection.*(..) throws SQLException) && target(connection);

    Object around( Connection connection ) : connectionOperation(connection) {//传递了上下文
        long startTime = System.nanoTime();
        Object ret = proceed();
        //thisJoinPoint是通知体可用的变量之一
        System.out.println( "Operation " + thisJoinPoint + " on " + connection + " took " + ( System.nanoTime() - startTime ) );
        return ret;
    }
}

上下文收集注解的例子：

before(Secured secured ) : 
    //匹配任何方法执行
    execution(* *(..)) 
    //匹配连接点目标————即方法本身————上具有@secured注解的连接点
    && @annotation(secured)
{
    //注解可以像普通对象一样被使用
    checkPermission(secured.permission());
}

上下文收集的另外一个例子，注意传递给目标的参数被收集，可被通知体使用：

package cc.gmem.aj;

public aspect AccountAspect
{

    boolean processOverdraft( Account account, float amount )
    {
        return true;
    }

    void around( Account account, float amount ) throws InsufficientBalanceException
    //匹配任何对Account.debit(float) throws InsufficientBalanceException方法的调用
        : call(void Account.debit(float) throws InsufficientBalanceException)
        && target(account) && args(amount)//收集的上下文信息作为局部变量使用
    {
        try
        {
            proceed( account, amount );//传递给目标方法的参数，可以任意修改
        }
        catch ( InsufficientBalanceException ex )
        {
            //进行透支处理
            if ( !processOverdraft( account, amount ) )
            {
                throw ex;
            }
        }
    }
}

在classpath的META-INF/aop.xml中，声明需要织入的切面：

<aspectj>
    <aspects>
        <aspect name="cc.gmem.aj.SecurityAspect"/>
    </aspects>
</aspectj>

通过指定JVM启动参数-javaagent来启用LTW：

-javaagent:%ASPECTJ_HOME%\lib\aspectjweaver.jar

如果使用Spring，可以通过配置，避免修改JVM启动参数

AspectJ支持连接点、切入点、切面等构造。

AspectJ的动态横切构造依赖于“通知”实现。通知包括Before、After、Around几种。

收集连接点上下文

连接点上下文包括两种类型：

通过反射访问连接点上下文

作为备选方式，AspectJ提供了基于反射机制的访问静态（不会随着连接点执行而变化的）、动态连接点上下文信息的方法。这种方式可以完全替换上一条进行动态上下文收集，但是具有以下缺点：

1. 性能较为低下
2. 缺少静态语法检查
3. 比较笨重

通过AspectJ提供的通知体可用的特殊变量来使用这种反射API：

两种访问连接点上下文的方式的对照表

静态横切总是在动态横切之前应用。

静态横切构造由：跨类型声明（inter-type declaration ，ITD，亦称“引入introduction)”）和织入时声明（weave-time declarations）组成
跨类型声明（引入）
可以修改类、接口、或者切面的静态结构，例如增加一个字段，添加一个接口。在一个切面中，声明其他类型的结构，故曰ITD。下面是一个例子：

package cc.gmem.aj;

public aspect TrackingAspect
{

    //声明MessageCommunicator实现接口AccessTracked，效果和Java标准语法一样
    declare      parents: MessageCommunicator implements AccessTracked;

    //声明AccessTracked类型的一个字段，所有它的子类型自动获取此字段
    private long AccessTracked.lastAccessedTime;

    //声明AccessTracked类型的两个方法，所有它的子类型自动继承这些方法
    public void AccessTracked.updateLastAccessedTime()
    {
        lastAccessedTime = System.currentTimeMillis();
    }

    public long AccessTracked.getLastAccessedTime()
    {
        return lastAccessedTime;
    }

    before( AccessTracked accessTracked ) : //声明了一个通知局部变量accessTracked
        execution(* AccessTracked+.*(..)) //AccessTracked子类型的任何方法
        && !execution(* AccessTracked.*(..))//除了AccessTracked本身的方法
        && this(accessTracked)//this对象收集为accessTracked变量
    {
        accessTracked.updateLastAccessedTime();
    }

    private static interface AccessTracked
    {
    }
}

成员引入的规则

1. 只能引入private、public成员，前者只能被切面类访问，后者可以被系统中所有类访问
2. 如果是private的，多个切面可以引入同名的成员
3. 切面可以引入字段、函数、构造器到类或者接口。特别的，可以引入方法的实现到接口——缺省实现
4. 如果切面引入一个和类中同名的方法，那么，类中的那个方法被保留
5. 成员引入只能针对一个类型

接口缺省实现的例子

package cc.gmem.aj;

public interface Nameable
{
    public void setName( String name );

    public String getName();
    //缺省实现
    static aspect Impl
    {
        private String Nameable.name;

        public void Nameable.setName( String name )
        {
            this.name = name;
        }

        public String Nameable.getName()
        {
            return this.name;
        }
    }
}

使用ITD来实现Java的Mixin机制

Mixin是一种程序构造，允许在已有类中混入特定的逻辑，Java语言没有语言级别的机制，下面的例子示意了如何使用AspectJ进行混入

//一个标记性接口，用于混入功能
public interface BeanSupport {}
//一个简单的POJO，需要混入：属性变更监听的功能
public class Customer implements BeanSupport
{
    private String address;
    public String getAddress()
    {
        return address;
    }
    public void setAddress( String address )
    {
        this.address = address;
    }
}

通过下面的代码，即可为Customer或者任何实现了BeanSupport的类型混入属性变更的功能，而没有任何的侵入性。

public aspect BeanMakerAspect
{

    private PropertyChangeSupport BeanSupport.propertyChangeSupport;
    public void BeanSupport.addPropertyChangeListener( PropertyChangeListener listener )
    {
        propertyChangeSupport.addPropertyChangeListener( listener );
    }
    public void BeanSupport.removePropertyChangeListener( PropertyChangeListener listener )
    {
        propertyChangeSupport.removePropertyChangeListener( listener );
    }
    pointcut beanCreation( BeanSupport bean )
    //匹配BeanSupport及其子类型的初始化连接点
    : initialization(BeanSupport+.new(..)) && this(bean);

    pointcut beanPropertyChange( BeanSupport bean, Object newValue )
    //匹配BeanSupport及其子类型的任何Setter方法的执行
    : execution(void BeanSupport+.set*(*))
    && args(newValue) && this(bean);
    //BeanSupport初始化成功后，创建一个propertyChangeSupport字段的实例
    after( BeanSupport bean ) returning : beanCreation(bean) {
        bean.propertyChangeSupport = new PropertyChangeSupport( bean );
    }
    //Setter调用后，发布相应的事件
    void around( BeanSupport bean, Object newValue )  : beanPropertyChange(bean, newValue) 
    {
        String methodName = thisJoinPointStaticPart.getSignature().getName();
        String propertyName = Introspector.decapitalize( methodName.substring( 3 ) );
        Object oldValue = getPropertyValue( bean, propertyName );
        proceed( bean, newValue );
        bean.propertyChangeSupport.firePropertyChange( propertyName, oldValue, newValue );
    }
}

修改类层次结构

AspectJ提供两种需要类层次的形式：

declare parents : [TypePattern] implements [InterfaceList];
declare parents : [TypePattern] extends [Class or InterfaceList];
//举例：所有实体类实现BeanSupport接口
public aspect EntityBeanParticipationAspect {
    declare parents: @Entity * implements BeanSupport;
}
//hasMethod、hasField，任何包含指定模式方法或者字段的类：
declare parents: hasmethod(@Observed * *(*)) implements BeanSupport;

引入注解

AspectJ支持为字段、类、方法等添加注解

简化异常处理

允许不强制捕获受查异常，声明方式如下：

//这里声明不需要强制捕获的异常
declare soft : <ExceptionTypePattern> : <pointcut>;

织入时声明——警告或者错误信息

可以在织入时，根据一定的模式来生成错误或者警告信息，举例：

//当doAuthenticate方法在SecurityAspect以外调用时，生成警告
declare      warning: 
    call(void Authenticator.doAuthenticate()) //切入点：方法被调用的地方，与execution不同
    && !within(SecurityAspect)  : //切入点，不在SecurityAspect内
        
        "Authentication should be performed only by SecurityAspect";

这种场景下，本质上还是Spring基于JDK动态代理的AOP机制，只是借用AspectJ的语法。

<?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:aop="http://www.springframework.org/schema/aop"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    ">
    <!-- 提示Spring自动为目标对象创建代理 -->
    <aop:aspectj-autoproxy />
    <!-- 声明普通Bean -->
    <bean id="messageCommunicator" class="cc.gmem.aj.MessageCommunicator" />
    <!-- 声明切面Bean，注意，必须使用注解语法定义切面 -->
    <bean id="securityAspect" class="cc.gmem.aj.SecurityAspect" />
</beans>

可以基于AspectJ，而不是Spring AOP来实现：事务管理、缓存、任务调度等常用AOP场景，以避免Spring AOP的固有缺陷。
特别是使用@Configurable注解来支持非Spring Bean的依赖注入，必须基于AspectJ完成。

<!-- 支持非受管对象（Spring Bean）的依赖注入和生命周期注解 -->
<context:spring-configured />
<!-- 支持基于AspectJ的事务管理 -->
<tx:annotation-driven transaction-manager="txManager" mode="aspectj" />
<!-- 支持基于AspectJ的缓存机制-->
<cache:annotation-driven cache-manager="cacheManager" mode="aspectj" />
<!-- 支持基于AspectJ的任务调度和执行 -->
<task:annotation-driven  scheduler="taskScheduler" executor="taskExecutor" mode="aspectj" />

The post AspectJ编程学习笔记 appeared first on 绿色记忆.

<bean id="demoJob" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
    <!-- 目标Bean -->
    <property name="targetObject">
        <bean class="cc.gmem.demo.DemoService" />
    </property>
    <!-- 目标方法 -->
    <property name="targetMethod" value="doStuff" />
    <!-- 防止并发执行 -->
    <property name="concurrent" value="false" />
</bean>
<!-- 简单触发器 -->
<bean id="simpleTrigger" class="org.springframework.scheduling.quartz.SimpleTriggerBean">
    <property name="jobDetail" ref="demoJob" />
    <!-- 启动后，调度开始的时间 -->
    <property name="startDelay" value="0" />
    <!-- 每隔2000ms调度一次 -->
    <property name="repeatInterval" value="2000" />
</bean>
<!-- Cron触发器 -->
<bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean">
    <property name="jobDetail" ref="demoJob" />
    <property name="cronExpression" value="15 0/2 * * * ?" />
</bean>
<!-- 调度工厂Bean -->
<bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="triggers">
        <list>
            <ref bean="simpleTrigger" />
            <ref bean="cronTrigger" />
        </list>
    </property>
</bean>

<!--  任务调度器配置，pool-size为线程池大小，限制了同时最多被调度的任务 -->
<task:scheduler pool-size="100" id="scheduler" />
<!-- 任务计划列表，支持固定频率、固定延迟、Cron表达式等 -->
<task:scheduled-tasks scheduler="scheduler">
    <task:scheduled fixed-rate="120000" method="doStuff" ref="demoService" />
    <task:scheduled cron="15 0/2 * * * ?" method="doStuff" ref="demoService" />
</task:scheduled-tasks>

<task:annotation-driven scheduler="scheduler" executor="taskExecutor" mode="aspectj" />
<task:scheduler pool-size="100" id="scheduler" /

package cc.gmem.demo;
@Component("demoService") 
public class DemoService(){
    @Scheduled(cron = "15 0/2 * * * ?")  
    public void doStuff(){

    }
}

import static org.quartz.JobBuilder.*;
import static org.quartz.TriggerBuilder.*;
import static org.quartz.SimpleScheduleBuilder.*;
import static org.quartz.CronScheduleBuilder.*;

StdSchedulerFactory schedulerFactory = new StdSchedulerFactory();
Properties pros = new Properties();
pros.setProperty( "org.quartz.scheduler.instanceName", "MyScheduler" );
pros.setProperty( "org.quartz.threadPool.threadCount", "10" );//调度器线程数
pros.setProperty( "org.quartz.jobStore.class", "org.quartz.simpl.RAMJobStore" );//任务存储，可以用于持久化
schedulerFactory.initialize( pros );
Scheduler scheduler = schedulerFactory.getScheduler();
//启动调度器
scheduler.start();
JobDetail job = newJob( helloWorldJob.class ).build();
//简单触发器
Trigger trigger =  newTrigger().startNow().withSchedule( simpleSchedule().withIntervalInSeconds( 1 ).repeatForever() ).build();
//Cron表达式触发器
trigger = newTrigger().startNow().withSchedule( cronSchedule( "15 0/2 * * * ?" )).build();
scheduler.scheduleJob( job, trigger );

TimeUnit.SECONDS.sleep( 1800 );
//关闭调度器
scheduler.shutdown();

The post Spring与Quartz的任务调度比较 appeared first on 绿色记忆.

@Service("as")
@Qualifier("default")
public class AService{

}

public class BService{
    @Resource
    @Qualifier("default")
    private AService aService;
}

可以在基于XML、注解的配置中使用Spring EL，语法格式：

#{ <expression string> }

XML配置示例：

<!-- 调用静态方法 -->
<bean id="numberGuess" class="org.spring.samples.NumberGuess">
    <property name="randomNumber" value="#{ T(java.lang.Math).random() * 100.0 }"/>
</bean>

<!-- 你可以直接引用其它Bean的属性，或者调用其方法：-->
<property name="initialShapeSeed" value="#{ numberGuess.randomNumber }"/>


<!-- 变量systemProperties是预定义的，你可以通过它访问系统属性 -->
<property name="defaultLocale" value="#{ systemProperties['user.region'] }"/>

注解配置示例：

# 访问系统属性
@Value("#{systemProperties['user.country']}")
# 访问环境变量
#{systemEnvironment['DDEPUB_ORDINAL']}

<!-- Spring -->
<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
</context-param>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:application.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- Spring MVC-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.XmlWebApplicationContext</param-value>
    </init-param>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:application-mvc.xml</param-value>
    </init-param>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

 即，在web.xml中直接声明XML配置文件的路径，如果需要引入额外的XML配置，可以使用<import>指令：

<import resource="core.xml"/>

 如果要引入额外的JavaConfig类，可以定义Bean：

<bean class="cc.gmem.BeanDefinitionRegistrar" /> 

<!-- Spring -->
<context-param>
    <param-name>contextClass</param-name>
    <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
</context-param>
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>cc.gmem.SpringBeanDefinitionRegistrar</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<!-- Spring MVC-->
<servlet>
    <servlet-name>springmvc</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextClass</param-name>
        <param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext</param-value>
    </init-param>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>cc.gmem.SpringMVCBeanDefinitionRegistrar</param-value>
    </init-param>
</servlet>

<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>

即，在web.xml中直接声明JavaConfig类的权限定名，如果需要引入额外的XML配置，需要在JavaConfig类中引入： 

@Configuration
/* 引入额外的XML配置文件 */
@ImportResource ( "classpath:pems-application.xml" )
public class SpringBeanDefinitionRegistrar
{

    /* Auto injected spring context */
    @SuppressWarnings ( "unused" )
    @Inject
    private ApplicationContext applicationContext;

    /* 编程式的创建Bean，默认是单例的 */
    @Bean ( name = "helper" )
    public Helper helper()
    {
        Helper helper = new Helper();
        return helper;
    }

}

@Configuration
/* 引入额外的XML配置文件 */
@ImportResource ( "classpath:pems-application-mvc.xml" )
public class SpringMVCBeanDefinitionRegistrar
{

}

JavaConfig方式中，尝试通过XML Bean的方式引入额外的JavaConfig类，会出现问题（3.1.2版本的Spring），行为不符合预期。

即使合理配置了Hibernate Session Factory、TransactionManager，在@PostConstruct方法上也加了事务配置（@Transactional），依旧无法进行数据库操作，报错：No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here

原因：在此（InitializingBean.afterPropertiesSet ）阶段，无法保证所有PostProcessors 完成其工作

解决：有两种方案：

1. 注册 ContextRefreshedEvent 的监听器，在监听方法里，可以确保事务机制可用
2. 在@PostConstruct方法里面使用TransactionTemplate，例如：
   

   private PlatformTransactionManager transactionManager;
   @PostConstruct
   public void init() throws Throwable
   {
       TransactionTemplate tt = new TransactionTemplate( transactionManager);
       tt.execute( new TransactionCallback<Object>() {
   
           @SuppressWarnings ( "unchecked" )
           public Object doInTransaction( TransactionStatus status )
           {
               List<User> = userService.getAllUsers();
               return null;
           }
       } );
   }

如果@Configurable无法在构造器里面使用注入的实例变量的问题，是因为默认情况下，仅在构造器执行完毕后Spring才进行依赖注入，要改变此行为，可以配置：

@Configurable(preConstruction=true)

下面是一个动态注册Hibernate SessionFactory的例子：

ctx = new GenericApplicationContext();
   ctx.addBeanFactoryPostProcessor( new BeanFactoryPostProcessor() {
      @Override
      public void postProcessBeanFactory( ConfigurableListableBeanFactory bf ) throws BeansException
      {
          DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) bf;
          beanFactory.registerSingleton( "memDS", memDS );
          BeanDefinitionBuilder sffbBeanDefBuilder = BeanDefinitionBuilder
                  .rootBeanDefinition( TestHibernate3LocalSessionFactoryBean.class );
          sffbBeanDefBuilder.addPropertyReference( "dataSource", "memDS" );
          Properties hprops = new Properties();
          hprops.setProperty( "hibernate.dialect", "org.hibernate.dialect.HSQLDialect" );
          hprops.setProperty( "hibernate.jdbc.batch_size", "20" );
          hprops.setProperty( "hibernate.show_sql", "true" );
          hprops.setProperty( "hibernate.format_sql", "false" );
          hprops.setProperty( "hibernate.generate_statistics", "true" );
          hprops.setProperty( "hibernate.default_entity_mode", "dom4j" );
          hprops.setProperty( "hibernate.transaction.factory_class", "org.hibernate.transaction.JDBCTransactionFactory" );
          hprops.setProperty( "hibernate.current_session_context_class",
                  "org.springframework.orm.hibernate3.SpringSessionContext" );
          hprops.setProperty( "hibernate.default_entity_mode", "dom4j" );
          sffbBeanDefBuilder.addPropertyValue( "hibernateProperties", hprops );
          beanFactory.registerBeanDefinition( "sessionFactory", sffbBeanDefBuilder.getBeanDefinition() );
      }
  } );
ctx.refresh();

下面是运行时获取beanFactory引用，并注册任意Bean的例子：

BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition("cc.gmem.ClassQName"); 
builder.addPropertyReference("refProp", "refBeanId");
builder.addPropertyValue("prop", object);
BeanDefinitionRegistry registry  = (BeanDefinitionRegistry)this.beanFactory;
registry.registerBeanDefinition("myNewBean", builder.getBeanDefinition());   
registry.removeBeanDefinition("myNewBean");

参考下例：

import java.util.List;

import org.hibernate.Query;
import org.hibernate.SessionFactory;
import org.hibernate.classic.Session;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Transactional;
/*设置单元测试运行类*/
@RunWith ( SpringJUnit4ClassRunner.class )
/*加载Spring配置文件*/
@ContextConfiguration ( { "/applicationContext.xml" } )
/*事务配置，defaultRollback 表示是否强制回滚事务 */
@TransactionConfiguration ( transactionManager = "txManager", defaultRollback = false )
public class HibernateTest
{
    private static final Logger LOGGER = LoggerFactory.getLogger( HibernateTest.class );

    @Test
    @Transactional
    public void testPolymorphicHqlQuery()
    {
        String hql = "from AbstractDevice ad where ad.status = 1";
        Session sess = Env.get( SessionFactory.class ).getCurrentSession();
        Query q = sess.createQuery( hql );
        @SuppressWarnings ( "unchecked" )
        List ads = q.list();
        for ( AbstractDevice ad : ads )
        {
            LOGGER.debug( ad.toString() );
        }
    }
}

添加依赖：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
    <version>${spring.version}</version>
</dependency>

报错信息：Exiting with throwable: java.lang.IllegalArgumentException: org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [jar:file:]; nested exception is java.lang.ArrayIndexOutOfBoundsException: 51880

原因：Spring 3.x无法支持Java8的Lambda，需要升级到Spring 4.x

原因：Maven传递依赖 cxf-rt-transports-http -> spring-web-3.0.6，导致本来应该用的3.1.2被覆盖
解决：排除传递性依赖

<context:component-scan base-package="cc.gmem.demo">
    <context:exclude-filter type="annotation" expression="org.springframework.context.annotation.Configuration" />

在Advice类上添加注解：数字越小，越先执行，例如：@Order(1)

Spring AOP具有以下缺点：

1. 无法对通知类进行通知
2. 目标对象调用自身的方法，则该方法上的通知不被执行（无法感知）——这是动态代理机制的本身特点决定的

解决方法：

1. 避免被代理对象的自我调用
2. 使用AopContext.currentProxy() 得到当前对象的代理，对代理调用被通知方法，注意，使用currentProxy时，应使用getter/setter，避免直接访问字段。需要配置：
   

   <!—基于AspectJ注解风格的Spring AOP事务配置--> 
   <aop:aspectj-autoproxy expose-proxy="true"/>
   <!—基于XML的声明式事务配置--> 
   <aop:config expose-proxy="true">

Spring配置文件的例子：使用Spring AOP，结合AspectJ风格的切面声明

基于AspectJ注解的切面类的例子：

@Aspect //加这个注解表示为通知类
@Component
public class LoggerPointcutsDefinition    //切入点定义
{
    //注意：Spring AOP支持AspectJ切入点的子集
    @Pointcut ( "@annotation(cc.gmem.mgr.common.aop.AutoLogError)" )
    public void inServiceLayer(){}
}

@Aspect
@Component
public class LoggerAdvice                  //通知定义
{
    private static final Logger LOGGER = LoggerFactory.getLogger( LoggerAdvice.class );
 
    @AfterThrowing ( value = "cc.gmem.mgr.common.aop.LoggerPointcutsDefinition.inServiceLayer()", throwing = "t" )
    public void logError( Throwable t ) {
        LOGGER.error( t.getMessage(), t );
    }
}

FactoryBean接口包含方法：

getObject()

<import resource="classpath:spring-config.xml" /> 

The post Spring知识集锦 appeared first on 绿色记忆.