Spring框架配置详解-优快云博客

本文链接：https://blog.youkuaiyun.com/zhaozengguang/article/details/13766113

（摘自 Pro Spring MVC With Web Flow,Deinum,Deinum,Sernells,Yates,Ladd,Vanfletern,Apress)

一、@Configuration 注解注意事项：

1、Configuration 类可以是 abstract 的，但不可以是 final 的，因为 spring 容器动态创建其子类。

二、applicationContext加载路径：

1、spring加载配置文件采取ant的正则表达式，classpath: 表示从项目根目录加载，classpath*:表示从当前层次，classpath**:表示从当前目录及其子目录。file:表示文件系。

http:表示web程序的根目录。

2、FileSystemXmlApplicationContext 只能从本地文件系统加载，不能加载web上的配置文件。

三、用配置类配置：

1、可以用配置类配置，例如：

@Configuration
public class ApplicationContextConfiguration {

	@Bean
	public AccountRepository accountRepository() {
		return new AccountRepository();
	}

	@Bean
	public TransactionRepository transactionRepository() {
		return new TransactionRepository();
	}
	
	@Bean
	public MoneyTransferService moneyTransferService() {
		return new MoneyTransferServiceImpl();
	}
}

加载的时候用

new AnnotationConfigApplicationContext(ApplicationContextConfiguration.class)；

加载。bean的名称就是方法的名称。

不过很少看到在项目中这么干。

2、配置类使用component-scan:

只需要加上注解

org.springframework.context.annotation.ComponentScan

配置类就支持扫描。

例如：

@ComponentScan(basePackages = {
"packagea",
"packageb" })

小心：把扫描路径设置为整个classpath,或过于靠近根路径，如com.apress之类的不是一个好想法，会导致服务启动的时间过长。相信各位程序员一定有过调试时一个项目启动10多秒的时候吧，所以最好别这么设置。

四、component-scan：

1、component-scan目前支持的5种注解：

org.springframework.stereotype.Component 
org.springframework.stereotype.Service
org.springframework.stereotype.Repository
org.springframework.stereotype.Controller
org.springframework.context.annotation.Configuration

五、scope（作用域）

1、spring作用域有7种：singleton prototype thread request session globalSession application。

(1) singleton：单例，spring默认的，用于无状态的bean，就是那种方法都是给个参数，返回个值，无副作用的bean。

(2) prototype：原型，需要一个bean的时候就new 一个

(3) thread：线程，如题，在线程范围内需要bean的时候就绑定一个到当前线程，线程结束，destroy bean 。

(4) request：请求，绑定在javax.servlet.ServletRequest中，请求over，就destroy。

(5) session：会话，绑定在javax.servlet.HttpSession，session destroy，bean destroy。

(6) globalSession：全局会话，在一个portlet 范围内有效。portlet 由jsr-168定义，jsr-268更新，类似于一个子application的东东。如果没有portlet，那么就跟session是一样的。

(7) application：应用程序，绑定在javax.servlet.ServletContext，和singleton的bean很像，一个application里面只有一个bean。老实说，除了被绑定对象不同，看不出和singleton bean 有何不同。

六、Profiles（配置）

1、从spring3.1开始引入，使我们的application（程序）对于不同的environment（环境）使用不同的configuration（配置），增强了程序的可移植性与可测试性。例如可以对测试云环境配置不同的profiles。指定 profile，则只加载这个 profile 中的 bean

2、使用之前，需要告诉程序激活那个configuration。通过设置spring.profiles.active来告诉系统。在web环境下，作为一个 servlet initialization parameter 或者一个 web context parameter 参数进行设置。在哪里设置？嗯，还是多加一句：在web.xml中。

3、用配置类加 profile

只需加注解

org.springframework.context.annotation.Profile

//示例
@Configuration
@Profile(value = "test")

//用法
System.setProperty("spring.profiles.active","test")

多一句，很多 Profile 一般定义在配置类的静态内部类上，例如：

@Configuration
public class ApplicationContextConfiguration {
    @Bean
    public Class1 bean1() {
        return new Class1();
    }

    @Configuration
    @Profile(value = "test")
    public static class TestConfig {
        @Bean
        public Class2 class2() {
            return new TestClass2();
        }
    }
    @Configuration
    @Profile(value = "local")
    public static class LocalConfig {
        @Bean
        public Class2 class2() {
            return new LocalClass2();
        }
    }
}

七、***增加内容

书中spring 版本为2.X

spring 3.x 中开始支持的注解：

1、org.springframework.transaction.annotation.EnableTransactionManagement (启用TransactionManagement)

启用特性后，支持@Transaction注解，从而自动提交与回滚。

外带提一句，spring 官方文档对其 Transaction management 这样介绍：

1、为model提供统一的 transaction api。如 java transaction api (JTA) ,hibernate,jdbc,java persistence api (JPA),java data api (JDA)。

2、支持声明式事物管理。(declarative transaction management)

3、相较于 JTA 等，提供更简单的 API。

4、对spring 的数据访问抽象进行了出色的整合。

实际使用中也确实方便不少

2、org.springframework.context.annotation.EnableAspectJAutoProxy (启用切面自动代理)

启用特性后，支持@Aspect注解。

用法

//方式一：注解类
@Configuration
 @EnableAspectJAutoProxy
 public class AppConfig {
     @Bean
     public FooService fooService() {
         return new FooService();
     }

     @Bean
     public MyAspect myAspect() {
         return new MyAspect();
     }
 }

//方式二：注解+扫描
//方式一：注解类
@Component
public class FooService {
     // various methods
 }

//实际使用，定义一个注解

@Aspect
 public class MyAspect {
     //切片对象 * FooService+.*(..) 的意思是返回任意方法的 FooService 类中的所有任意参数的方法。
     //其他的切面定义方法参照 java 反射API
     @Before("execution(* FooService+.*(..))")
     public void advice() {
         // advise FooService methods as appropriate
     }
 }

3、org.springframework.scheduling.annotation.EnableAsync（启用异步支持）

提供类似于<task:的功能，用法：(1)注解方式：
@Configuration
 @EnableAsync
 public class AppConfig implements AsyncConfigurer {

     @Bean
     public MyAsyncBean asyncBean() {
         return new MyAsyncBean();
     }

     @Override
     public Executor getAsyncExecutor() {
         ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
         executor.setCorePoolSize(7);
         executor.setMaxPoolSize(42);
         executor.setQueueCapacity(11);
         executor.setThreadNamePrefix("MyExecutor-");
         executor.initialize();
         return executor;
     }
 }

(2) xml方式：

<beans>
     <task:annotation-config executor="myExecutor"/>
     <task:executor id="myExecutor" pool-size="7-42" queue-capacity="11"/>
     <bean id="asyncBean" class="com.foo.MyAsyncBean"/>
 </beans>

在xml中使用，需引入命名空间

xmlns:task="http://www.springframework.org/schema/task"

在schemaLocation中引入

http://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsd

4、org.springframework.cache.annotation.EnableCaching

允许缓存，与xml配置中<catch:* 对应。

用法：

 
@Configuration
 @EnableCaching
 public class AppConfig {
     @Bean
     public MyService myService() {
         // configure and return a class having @Cacheable methods
         return new MyService();
     }

     @Bean
     public CacheManager cacheManager() {
         // configure and return an implementation of Spring's CacheManager SPI
         SimpleCacheManager cacheManager = new SimpleCacheManager();
         cacheManager.addCaches(Arrays.asList(new ConcurrentMapCache("default")));
         return cacheManager;
     }
 }

在上述用法中，必须有一个返回 CacheManager 的 cacheManager 方法。

或者

@Configuration
 @EnableCaching
 public class AppConfig implements CachingConfigurer {
     @Bean
     public MyService myService() {
         // configure and return a class having @Cacheable methods
         return new MyService();
     }

     @Bean
     @Override
     public CacheManager cacheManager() {
         // configure and return an implementation of Spring's CacheManager SPI
         SimpleCacheManager cacheManager = new SimpleCacheManager();
         cacheManager.addCaches(Arrays.asList(new ConcurrentMapCache("default")));
         return cacheManager;
     }

     @Bean
     @Override
     public KeyGenerator keyGenerator() {
         // configure and return an implementation of Spring's KeyGenerator SPI
         return new MyKeyGenerator();
     }
 }

上述方法继承了 CachingConfigurer ，必须实现 cacheManager 和 keyGenerator 两个方法。

5、org.springframework.context.annotation.EnableLoadTimeWeaving(允许时间监控)

用法

@Configuration
 @EnableLoadTimeWeaving
 public class AppConfig {
     // application-specific @Bean definitions ...
 }

或者

@Configuration
 @EnableLoadTimeWeaving
 public class AppConfig implements LoadTimeWeaverConfigurer {
     @Override
     public LoadTimeWeaver getLoadTimeWeaver() {
         MyLoadTimeWeaver ltw = new MyLoadTimeWeaver();
         ltw.addClassTransformer(myClassFileTransformer);
         // ...
         return ltw;
     }
 }

对应的XML配置：

<beans>
     <context:load-time-weaver weaverClass="com.acme.MyLoadTimeWeaver"/>
 </beans>

这个东东对于日志记录很有用，用法就是，嗯!，还是提一句：getBena("loadTimeWeaver")。呵呵。

6、org.springframework.scheduling.annotation.EnableScheduling(启用调度器)

启动后可以使用定时任务调度。

用法

@Configuration
@EnableScheduling
public class AppConfig{
}

启用后将注册启用有

@Scheduled

注解的bean

例如：

public class MyTask{
    @Scheduled(fixedRate=1000)
    public void work(){
        System.out.println("balabala")
    }
}

相应的配置类：

@Configuration
@EnableScheduling
public class AppConfig{

    @Bean
    public MyTask myTask{
        return new MyTask();
    }
}

以上配置会使new MyTask().work() 每1秒钟执行一次。

用法2：

@Configuration
@EnableScheduling
 public class AppConfig implements SchedulingConfigurer {
     @Override
     public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
         taskRegistrar.setScheduler(taskExecutor());
     }

     @Bean(destroyMethod="shutdown")
     public Executor taskExecutor() {
         return Executors.newScheduledThreadPool(100);
     }
 }

需要实现 configureTasks 和 taskExecutor 两个方法。

更复杂的实现方法：

@Configuration
@EnableScheduling
public class AppConfig implements SchedulingConfigurer {
     @Override
     public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
         taskRegistrar.setScheduler(taskScheduler());
         taskRegistrar.addTriggerTask(
             new Runnable() {
                 public void run() {
                     myTask().work();
                 }
             },
             new CustomTrigger()
         );
     }

     @Bean(destroyMethod="shutdown")
     public Executor taskScheduler() {
         return Executors.newScheduledThreadPool(42);
     }

     @Bean
     public MyTask myTask() {
         return new MyTask();
     }
 }

这里又添加了一个Task

对应的xml配置

<beans>
     <task:annotation-config scheduler="taskScheduler"/>
     <task:scheduler id="taskScheduler" pool-size="42"/>
     <task:scheduled ref="myTask" method="work" fixed-rate="1000"/>
     <bean id="myTask" class="com.foo.MyTask"/>
 </beans>

7、org.springframework.web.servlet.config.annotation.EnableWebMvc(允许mvc)

激活MVC特性，注册所有有@Controller注解的类

@Configuration
@EnableWebMvc
@ComponentScan(
       basePackageClasses = { MyConfiguration.class },
       excludeFilters = { @Filter(type = FilterType.ANNOTATION, value = Configuration.class) }
)
public class MyConfiguration {
}

注意上面的ComponentScan注解，里面有excludeFilters ={@Filter(type=FilterType.ANNOTATION,value=Configuration.class)}，把本配置文件排除在外。

要进行进一步的定制，可以实现WebMvcConfigurer 接口或者继承WebMvcConfigurerAdapter类。

例子：

@Configuration
 @EnableWebMvc
 @ComponentScan(
        basePackageClasses = { MyConfiguration.class },
        excludeFilters = { @Filter(type = FilterType.ANNOTATION, value = Configuration.class) }
 )
 public class MyConfiguration extends WebMvcConfigurerAdapter {

        @Override
        public void registerFormatters(FormatterRegistry formatterRegistry) {
                formatterRegistry.addConverter(new MyConverter());
        }

        @Override
        public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
                converters.add(new MyHttpMessageConverter());
        }

        ...

 }

八、面向切面编程

几个概念：切面(Aspect)、连接点(join point)、通知(Advice)、切入点(Pointcut)

切面(Aspect):横穿几个切面的类，用org.aspectj.lang.annotation.Aspect 注解标示。

连接点(join point)：程序执行过程中的一个点，在spring中，就是一个方法的执行。

通知(Advice)：切入点发生的行为，常见的@Before @After @AfterThrowing @AfterReturning @Around

切入点(Pointcut)：声明的所有符合条件的连接点，是一个Advice的集合。通过org.aspectj.lang.annotation.Pointcut 注解标识。

例子：

@Aspect
public class AfterThrowingExample {

  @AfterThrowing(
    pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()",
    throwing="ex")
  public void doRecoveryActions(DataAccessException ex) {
    // ...
  }

  
@AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
  public void doRecoveryActions() {
    // ...
  }

  
@Pointcut("execution(* com.xyz.someapp.service.*.*(..))")
  public void businessService() {}

}

注意上面的执行表达式(execution expression)：

语法：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)

解释下：

modifiers-pattern 访问权限匹配

ret-type-pattern 返回类型匹配

declaring-type-pattern 申明类型匹配(含包名)

name-pattern 方法名称匹配

param-pattern 参数匹配

throws-pattern 异常声明匹配

execute expression 中.. 表示所有 . 表示一个单词，*表示任意字母

九、实际web程序的入口：

1、org.springframework.web.servlet.DispatcherServlet

2、org.springframework.web.context.ContextLoaderListener

spring碎碎念