4.1 Spring核心组件

Spring框架的核心包括IOC、AOP以及辅助工具SpringEL等。

首先要明确一个概念，Spring的IOC容器是ApplicationContext。常用的ApplicationContext如下：

  • ClassPathXmlApplicationContext: 从ClassPath路径下加载XML配置的上下文。

  • FileSystemXmlApplicationContext：从文件系统中加载XML配置的上下文。

  • XmlWebApplicationContext：Web开发中从XML中记载Web上下文，区别于上面之处在于此上下文是基于ServletContext的。

  • AnnotationConfigWebApplicationContext：从注解类中加载Web上下文。

对于这些上下文中的实例在Spring中被叫做Bean。一个Bean的生命周期管理如下图所示：

图中所示为Spring中的几个关键类、接口以及对应的方法，箭头的方向表示执行的顺序，描述了一个Bean从开始初始化到销毁会经历的一些方法调用。

4.1.1 双亲上下文

Spring中的ApplicaitonContext是父子层次结构的，存在多个上下文的时候，会有一个根上下文做为其他上下文的父亲。

<listener>  
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    ...
</listener>

如上，如果在web.xml中使用Listener监听器来加载Spring的配置，Spring会创建一个全局的WebApplicationContext上下文，称为根上下文，保存在 ServletContext中，key是WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE属性的值。可以使用工具类取出上下文：WebApplicationContextUtils.getWebApplicationContext(ServletContext)或者WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext)。

而很多情况下，我们还会配置一个或者多个DispatcherServlet，每个DispatcherServlet有一个自己的WebApplicationContext上下文。这个上下文是私有的，继承了根上下文中所有东西。保存在ServletContext中，key是 "org.springframework.web.servlet.FrameworkServlet.CONTEXT" + Servlet名称。当一个Request对象产生时，会把这个WebApplicationContext上下文保存在Request对象中，key是DispatcherServlet.class.getName() + ".CONTEXT"。可以使用工具类取出上下文：RequestContextUtils.getWebApplicationContext(request)或者WebApplicationContextUtils.getWebApplicationContext(servletContext,attrname)。

为了避免双亲上下文，可以不使用Listener监听器来加载Spring的配置，直接改用DispatcherServlet来加载Spring的配置。

4.1.2 事件机制

Spring中提供了事件机制，用于监听容器事件的发生，在事件发生时做一些处理工作。

  1. 容器事件监听器：实现ApplicationListener接口的类, 可以监听容器的事件，包括：

    • ContextStartedEvent: 上下文启动事件

    • ContextRefreshedEvent：上下文刷新完毕事件

    • ContextStoppedEvent：上下文停止事件

    • ContextClosedEvent：上下文关闭事件

    @Service
public class TestListener implements ApplicationListener<ContextStartedEvent> {
    @Override
    public void onApplicationEvent(ContextStartedEvent event) {
        ...
    }
}

<bean class="me.rowkey.pje.spring.TestListener" scope="prototype" />

  2. 具有意识的Bean：形如xxAware的接口，实现了此种接口的Bean即为有意识，能够注入/获取到xx代表的事物。如，实现ApplicationContextAware接口的类，会自动注入当前的ApplicationContext。

    public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext applicationContext;

    public static ApplicationContext getContext() {
        return ApplicationContextHolder.applicationContext;
    }

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextHolder.applicationContext = applicationContext;
    }
}

<bean class="me.rowkey.pje.spring.ApplicationContextHolder"/>

    此外，在Bean生命周期图中的BeanNameAware和BeanFactoryAware也是两个具有意识的Bean。

    • 实现了BeanNameAware的Bean能够感知到自己在BeanFactory中注册的名称。

    • 实现了BeanFactoryAware的bean能够感知到自己所属于的BeanFactory。

4.1.3 初始化和销毁

如果想要在应用初始化的时候做一些初始化方法，可以使用以下几种初始化方式：

  1. 直接在Bean的构造方法里做初始化工作。

  2. 使用@PostConstruct注解，指明在Bean构造器方法执行后执行的方法。

  3. Bean实现InitializingBean接口，在afterPropertiesSet做初始化工作。

  4. 在XML中使用init-method指定Bean构造完成后调用的方法。

需要注意的是方法1和2并不保证在执行时依赖的其他Bean已经注入进来。因此如果想在某些Bean初始化完毕并注入进来之后再进行初始化工作，可以配合使用@DependsOn注解。

@Service
@DependsOn("configService")
public class AccountService implements Constants {

   @Resource
   private ConfigService configService;

   @PostConstruct
   public void init() throws IOException {
       ...
   }

}

也可以使用BeanFactoryPostProcessor和BeanPostProcessor来做一些更为前置的初始化工作, 典型的应用场景就是实现自己的注解。

  • 实现BeanFactoryPostProcesso接口可以在在Spring容器加载了Bean的定义之后，在Bean实例化之前执行，能够修改Bean的定义属性。如可以把Bean的scope从singleton改为prototype，也可以把property的值给修改掉。可以通过接口的参数获取到相关Bean的定义信息。

  • 实现BeanPostProcesso接口可以在Spring容器实例化Bean之后，在执行Bean的初始化方法前后，添加一些自己的处理逻辑。Spring内置了几个BeanPostProcessor实现：

    • CommonAnnotationBeanPostProcessor：支持@Resource注解的注入

    • RequiredAnnotationBeanPostProcessor：支持@Required注解的注入

    • AutowiredAnnotationBeanPostProcessor：支持@Autowired注解的注入

    • ApplicationContextAwareProcessor：用来为bean注入ApplicationContext等容器对象

根据Bean的生命周期。以上提到的初始化方法的优先级为: BeanFactoryPostProcessor > Constructor > BeanPostProcessor.postProcessBeforeInitialization > @PostConstruct > InitializingBean > init-method。

此外，如果是想要在所有Bean都初始化完毕后做一次初始化工作，那么可以使用上一节所说的ApplicationListener,监听ContextRefreshedEvent。

@Service
public class BootstrapService implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        ...//初始化代码
    }
}

而要在销毁Bean之前做一些收尾工作，有以下三种方式：

  • 使用@PreDestroy注解，指明在容器关闭后执行的方法。

  • 实现DisposableBean接口，在destroy方法做销毁工作。

  • 在XML中使用destroy-method指定bean销毁时调用的方法。

根据Bean生命周期，可知优先级为：@PreDestroy > DisposableBean > destroy-method。

4.1.4 动态构造Bean

当要创建的Bean不能直接通过构造方法、setter方法、字段注入完成，还需要做一些初始化工作的时候，普通创建Bean的方式就力不从心了。 Spring提供了三种方式解决这个问题：

  1. 定义Bean时，指明factory-bean和factory-method

    public class TestFactory{
    public User getUser(){
        return new User();
    }
}

<bean id="testFactory" class="me.rowkey.pje.spring.TestFactory"/>
<bean id="user" class="me.rowkey.pje.common.meta.User"
      factory-bean="testFactory" factory-method="getUser">
</bean>

  2. 定义Bean直接使用类的静态方法

    public class TestFactory{
   public static User getStaticUser(){
       return new User();
   }
}

<bean id="user" class="me.rowkey.pje.spring.TestFactory" factory-method="getStaticUser"/>

  3. 实现FactoryBean接口

    public interface FactoryBean<T> {
    T getObject() throws Exception;
    
    Class<?> getObjectType();
    
    boolean isSingleton();
}

public class TestFactory implements FactoryBean<User> {
    @Override
    public User getObject() throws Exception {
        return new User("test");
    }

    @Override
    public Class<?> getObjectType() {
        return User.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

<bean id="user" class="me.rowkey.pje.spring.TestFactory"/>

针对第3种方式的FactoryBean，Spring自带了几个实现。:

  • PropertyPathFactoryBean: 用来获取目标Bean的属性值（实际是其getter方法的返回值)。PropertyPathFactoryBean返回值（基本数值类型或者对象）在最外层，则把返回值注册为容器中一个Bean，Bean名字为id 。

    <bean id="propertyBean" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">  
      <property name="targetBeanName" value="adminUser"></property>  
      <property name="propertyPath" value="user.username"></property>  
</bean>  

<!--下面是简化形式-->
<bean id="adminUser.user.username" class="org.springframework.beans.factory.config.PropertyPathFactoryBean" />

  • FieldRetrievingFactoryBean：用来获取类的静态属性值或者对象的实例属性值。

    <bean id="java.sql.Connection.TRANSACTION_SERIALIZABLE" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"/>

    上面即获取类java.sql.Connection的静态属性值TRANSACTION_SERIALIZABLE。

  • MethodInvokingFactoryBean：用来调用类的静态方法或者调用Bean对象的实例方法。若有返回值则可注册为容器中的Bean或者作为依赖注入其它Bean中。

    <bean id="testUser" class="org.springframework.beans.factory.config.MethodInvokingFactoryBean">  
    <property name ="targetObject" ref="testFactory"></property>  
    <property name="targetMethod" value="getUser"></property>  
    <property name="arguments">  
        <list>  
        .....  
        </list>  
    </property>  
</bean>

同样的，可以用inner Bean的方式将上面的FactoryBean构造的实例注入到其他bean中：

<bean id="testUser" class="me.rowkey.pje.common.meta.User">  
   <property name="username">  
       <bean id="adminUser.user.username" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>  
   </property>  
  <property name="password">  
      <bean id="adminUser.user.password" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>  
  </property>  
</bean>

当然，现在Spring提供了@Bean注解，完全可以在代码中做这种动态生成Bean的工作。

@Configuration
public class SpringCoreConfig{

   @Bean("testUser")
   public User TestUser(AdminUser adminUser) { //参数可以直接引用bean
    
       User user = new User();
       user.setUsername(adminUser.getUser().getUsername());
       
       ...
       
       return user;
   }
}

4.1.5 注入集合、枚举、类的静态字段

  1. 对于在XML中已经存在的Bean注入List、Map等集合这种需求，可以这样配置：

    <!-- Bean的属性是集合 -->  
<bean id="collectionBean" class="me.rowkey.pje.spring.CollectionBean">  
  <property name="list">  
      <list>  
          <value>list1</value>  
          <value>list2</value>  
          <value>list3</value>  
      </list>  
  </property>  
   <property name="map">  
       <map>  
           <entry key="key1" value="value1"></entry>  
           <entry key="key2" value="value2"></entry>  
           <entry key="key3" value="value3"></entry>  
       </map>  
   </property>   
</bean>

  2. 注入枚举、静态值

    对于枚举和静态值的注入，使用FieldRetrievingFactoryBean是一种办法。但其实当注入的字段值属于此字段对应类的静态字段时，只需要注明静态字段名即可。如：

    public enum Status{
    ENABLE,DISABLE
}

public class ParentUser{  
  public static final ParentUser INSTANCE = new ParentUser();  
}  

public class User{
    private Status status;
    
    privata ParentUser parentUser;
    
    private void setStatus(Status status){
        this.status = status;
    }
    
    private Status getStatus(){
        return this.status;
    }
    
    private void setParentUser(ParentUser parentUser){
        this.parentUser = parentUser;
    }
    
    private ParentUser getParentUser(){
        return this.parentUser;
    }
}

<bean id="testUser" class="me.rowkey.pje.common.meta.User">
    <property name="status" value="ENABLE"/>
    <property name="parentUser" value="INSTANCE"/>
</bean>

4.1.6 AOP

AOP（Aspect Oriented Programming）是为了解决某些场景下代码重复问题的一种编程技术，允许程序模块化横向切割关注点或横向切割典型的责任划分。能够封装多个类中不同单元的相同功能，把应用业务逻辑和系统服务分开，经常用在日志和事务管理上。

说到AOP不得不提的就是Aspectj这个AOP框架，它是一种编译期AOP框架（即在编译的时候对被代理的类进行增强）。它自己有一套AOP各个组件的概念定义。其中的几个关键的概念如下：

  • 方面：Aspect,横切多个类的某个功能描述。比如，一个日志模块可以被称作日志的AOP切面。

  • 连接点：JointPoint, 程序执行过程中的某个函数调用。代表一个应用程序的某个位置，在这个位置我们可以插入一个AOP切面，它实际上是个应用程序执行Spring AOP的位置。

  • 通知: Advice, 是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。Spring切面可以应用五种类型的通知：

    • before：前置通知，在一个方法执行前被调用。

    • after: 在方法执行之后调用的通知，无论方法执行是否成功。

    • after-returning: 仅当方法成功完成后执行的通知。

    • after-throwing: 在方法抛出异常退出时执行的通知。

    • around: 在方法执行之前和之后调用的通知。

  • 切入点: PointCut, 是映射到一个或一组连接点的指示符，通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。Spring AOP支持的AspectJ切入点指示符如下：

    • execution：用于匹配方法执行的连接点；

    • within：用于匹配指定类型内的方法执行；

    • this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配；

    • target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配；

    • args：用于匹配当前执行的方法传入的参数为指定类型的执行方法；

    • @within：用于匹配所以持有指定注解类型内的方法；

    • @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解；

    • @args：用于匹配当前执行的方法传入的参数持有指定注解的执行；

    • @annotation：用于匹配当前执行方法持有指定注解的方法；

    • bean：Spring AOP扩展的，AspectJ没有此指示符，用于匹配特定名称的Bean对象的执行方法；

    • reference pointcut：表示引用其他命名切入点，只有@ApectJ风格支持，Schema风格不支持。

    其中类型匹配的语法如下所示：

      - *：匹配任何数量字符；
  
  - ..：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数。
  
  - +：匹配指定类型的子类型；仅能作为后缀放在类型模式后边。

    匹配类型表达式：注解？ 类的全限定名字；匹配方法执行表达式：注解？ 修饰符? 返回值类型 类型声明?方法名(参数列表) 异常列表？

    此外，多个切入点表达式是可以组合的，AspectJ使用 且（&&）、或（||）、非（！）来组合切入点表达式，为了方便xml配置，Spring AOP 提供了and、or、not来代替&&、||、！。

需要注意的是Spring AOP是一种运行期的AOP框架，对Aspectj的支持只是使用了其定义的各个组件定义和注解，底层实现和它并没有多少关系。

使用Spring AOP有三种方式：

  1. Spring AOP接口

    此种方式基于Spring提供的aop接口：

    • 前置通知：MethodBeforeAdvice

    • 后置通知：AfterReturningAdvice

    • 环绕通知：MethodInterceptor

    • 异常通知：ThrowsAdvice

    针对这些接口，进行实现并配置即可。此种方式需要对每一个被代理的bean创建一个ProxyFactoryBean并手动指定目标对象与通知，比较繁琐，笔者也不推荐使用，因此不再详细叙述。

  2. 依赖于Aspectj的XML配置

    Spring从2.0开始开始支持Aspectj的XML配置方式，在aop:config标签下使用aop:pointcut、aop:advisor、aop:aspect配置，自动完成动态代理工作，大大简化了aop的开发工作。如下：

    public class TestServiceAop{
    public void doAround(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("===========进入around环绕方法！=========== \n");

        // 调用目标方法之前执行的动作
        System.out.println("调用方法之前: 执行！\n");

        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object result = pjp.proceed();

        System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");
        System.out.println("调用方法结束：之后执行！\n");
    }
}

<bean id="testServiceAop" class="me.rowkey.pje.spring.aop.TestServiceAop" />

<aop:config>
    <aop:aspect ref="testServiceAop">
    
        <aop:pointcut id="point_cut" expression="execution(*  me.rowkey.pje.spring.aop.test.service.impl..*.*(..)))" />
        
        <aop:before .../>
        
        <aop:afterReturning .../>

        <aop:afterThrowing .../>
        
        <aop:after .../>
    
        <aop:around method="around" pointcut-ref="point_cut"/>
        
        <!--<aop:around method="around" pointcut="execution(* me.rowkey.pje.spring.service.impl..*.*(..)))"/>-->
    </aop:aspect>
</aop:config>

  3. 依赖于Aspectj注解的AOP配置

    Spring现在也支持使用Aspectj的注解来做AOP，比起XML配置的方式，更加简单。

    @Component
@Aspect
public class UserRestOperationLogAop {

    @Pointcut("execution(public * me.rowkey.pje.spring.service..*.add*(..)) " +
        "|| execution(public * me.rowkey.pje.spring.service..*.delete*(..)) " +
        "|| execution(public * me.rowkey.pje.spring.service..*.update*(..))" +
        "|| execution(public * me.rowkey.pje.spring.service..*.create*(..))" +
        "|| execution(public * me.rowkey.pje.spring.service..*.modify*(..))")
    public void pointCut() {
    }

    @Around(value = "pointCut()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("===========进入around环绕方法！=========== \n");

        // 调用目标方法之前执行的动作
        System.out.println("调用方法之前: 执行！\n");

        // 调用方法的参数
        Object[] args = pjp.getArgs();
        // 调用的方法名
        String method = pjp.getSignature().getName();
        // 获取目标对象
        Object target = pjp.getTarget();
        // 执行完方法的返回值：调用proceed()方法，就会触发切入点方法执行
        Object result = pjp.proceed();

        System.out.println("输出：" + args[0] + ";" + method + ";" + target + ";" + result + "\n");
        System.out.println("调用方法结束：之后执行！\n");
    }
}

<context:component-scan base-package="me.rowkey.pje.spring" />
<!-- 打开aop 注解 -->
<aop:aspectj-autoproxy />

Spring中AOP的实现原理包括两种方式：JDK动态代理和CGLIB。

  • 如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP。

  • 如果目标对象实现了接口，可以强制使用CGLIB实现AOP。

  • 如果目标对象没有实现了接口，必须采用CGLIB库，Spring会自动在JDK动态代理和CGLIB之间转换。

也可以强制AOP使用CGLIB，如下

//XML配置
<aop:aspectj-autoproxy proxy-target-class="true"/>

//注解配置
@EnableAspectJAutoProxy(proxyTargetClass = true)

4.1.7 XML配置进阶

XML是Spring一开始就支持的配置方式，也是最主流的配置方式。从Spring 2.0开始，基于文件的配置就从DTD转换到了XSD，目的就是让大家能够更好地利用XSD做到配置的灵活性和便利性。这里首先要注意的是在加载XML文件时，通常会有前缀classpath:和者classpath*：这俩的区别在于当classpath中存在同样路径的多个文件时，前者只会去加载第一个找到的资源，而后者则会去加载所有找到资源。路径的对照表如下：

前缀例子说明

classpath:

classpath:applicationContext.xml

从classpath中加载

file:

file:/data/applicationContext.xml

作为 URL 从文件系统中加载。

http:

http://host/applicationContext.xml

作为 URL 加载。

（none）

/data/applicationContext.xml

根据上下文的不同而不同: FileSystemXmlApplicationContext对应文件系统；GenericWebApplicationContext对应ServletContext中的资源;ClassPathXmlApplicationContext对应Classpath下的资源。

之前IOC和MVC两章都有一些基本的Spring xml配置示例，这里主要讲解一些可能不是所有人都知道的知识点。首先看下面的一个配置示例：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:p="http://www.springframework.org/schema/p"
      xmlns:c="http://www.springframework.org/schema/c"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd">
       <bean class="me.rowkey.test.TestBean" p:name="uname" p:refBean-ref="refBean">
           <property name="type" value="1"/>
       </bean>
       <beans profile="dev">
           <bean id="bean2" class="me.rowkey.pje.spring.TestBean" c:name="testName">
               <property name="refBean">
                   <null/>
               </property>
           </bean>
       </beans>
</beans>

对上述示例配置的说明如下：

  • xsi:schemaLocation：是为了指出XSD文件可以在本地jar包中找到，无须去网络位置获取。

  • p:xx：对属性赋值的简化，作用于属性注入。

  • c:xx：构造注入的简化。

  • 使用<null/>引用null值。

  • 从Spring3开始，beans多了一个profile属性可以根据不同的profile使用不同的bean，可以用在本地、测试、生产环境使用不同的日志、数据库配置这种场景下。上面的bean2即表示在profile为dev时，才会初始化这个bean。其中，profile通过spring.profiles.active和spring.profiles.default这俩Java运行属性或者SPRING_PROFILES_DEFAULT和SPRING_PROFILES_ACTIVE环境变量来指定。此外，对于ContextLoaderListener,在web.xml可以配置其默认profile：

    <context-param>
    <param-name>spring.profiles.default</param-name>
    <param-value>local</param-value>
</context-param>

    对于DispatchServlet，在web.xml中配置：

    <servlet>
    <init-param>
      <param-name>spring.profiles.default</param-name>
      <param-value>local</param-value>
    </init-param>
</servlet>

除了beans之外，spring还提供了很多额外的namespace以简化配置。

  • context： 此namespace下的配置主要是对上下文的配置简化。

    • annotation-config：开启注解装配。隐式地向Spring容器注册AutowiredAnnotationBeanPostProcessor、RequiredAnnotationBeanPostProcessor、CommonAnnotationBeanPostProcessor以及PersistenceAnnotationBeanPostProcessor这4个BeanPostProcessor。

    • component-scan: 指定注解扫描的包路径。此配置包含了annotation-config的功能，因此如果配置了component-scan，那么annotation-config是可以省略的。

    • property-holder：根据指定的location扫描properties文件以及系统属性和环境变量，存储里面的键值对, 在XML配置里可以使用占位符${}引用。在代码中，可以使用注解@Value + 占位符引用。

  • util：此namepace下主要是提供了一些构建Bean的工具。

    • constant：根据表达式创建指定静态字段作为bean，可替代FieldRetrievingFactoryBean的使用。

    • property-path: 获取指定path的属性作为bean，可替代PropertyPathFactoryBean的使用。

    • properties: 从指定位置加载properties文件，创建一个java.util.Properties实例bean。后面就可以引用此bean的属性。可替代PropertiesFactoryBean的使用。

    • list：创建一个列表bean。可替代ListFactoryBean的使用。

    • map：创建一个map bean。可替代MapFactoryBean的使用。

    • set：创建一个set bean。可替代SetFactoryBean的使用。

  • mvc

    • annotation-driven: 开启MVC的注解支持，创建了和MVC、注解相关的一系列Bean，如RequestMappingHandlerMapping、RequestMappingHandlerAdapter等。

      • message-convertors: annotation-driven的子元素，用来配置HttpMessageConvertor。

      • argument-resolvers: annotation-driven的子元素,用来配置项目用到的自定义HandlerMethodArgumentResolver。

    • interceptors：配置项目用到的拦截器

    • content-negotiation: view-resolvers的子元素，配置内容协商视图。

      <mvc:view-resolvers>
    <mvc:content-negotiation>
        <mvc:default-views>
            <bean class="org.springframework.web.servlet.view.json.MappingJackson2JsonView"/>
        </mvc:default-views>
    </mvc:content-negotiation>
    <mvc:jsp/>
</mvc:view-resolvers>

4.1.8 注解+代码配置

现在利用注解+代码配置变得越来越流行。基本上对应着每一个XML配置都有相应的注解配置与之对应。常用的注解配置如下：

  • @Configuration: 表示此类的用途是用来定义Bean的。

  • @Bean：注解到方法上，创建、初始化一个Bean。对应于配置。

  • @Profile：对应于, 指定某个profile激活的Bean等。

  • @ComponentScan：对应于context:component-scan配置，扫描对应的包。

  • @EnableWebMVC: 对应于mvc:annotation-driven配置，开启MVC注解支持。配合@Configuration使用。被注解的对象实现WebMvcConfigurer接口（一般继承WebMvcConfigurerAdapter即可）可以自定义配置拦截器、视图协商器、MessageConverters等等。

  • @Import： @Import允许将其它JavaConfig形式的配置类引入到当前的@Configuration标注的配置类当中，对应于原来XML中的 ，也可以通过@ImportResource将XML形式定义的配置引入当前JavaConfig形式的配置类当中。

  • @PropertySource：配合@Configuration使用，用来加载.properties内容到Environment，比如： @PropertySource("classpath:config.properties")，需要容器中配置一个PropertySourcesPlaceholderConfigurer。

一个配置示例如下：

@Configuration
@ImportResource({
    "classpath:applicationContext-core.xml"
})

@Import(SpringExtraConfig.class)
@ComponentScan(basePackages = {
        "me.rowkey.pje.spring.mvc"
}, excludeFilters = {
        @ComponentScan.Filter(type = FilterType.REGEX, pattern = "test\\.mvc\\.web\\..*"),
        @ComponentScan.Filter(type = FilterType.REGEX, pattern = "test\\.mvc\\.spring\\..*")
})
@@PropertySource("classpath:config.properties")//内容：sms.url=http://xxx/api/ams
@EnableWebMVC
public class SpringCoreConfig extends WebMvcConfigurerAdapter{

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

        registry.addInterceptor(new MyCustomInterceptor()).addPathPatterns("/**").excludePathPatterns("/admin/**");
    }

   //Bean注解里面的name如果为空，那么bean的id为方法的名字
    @Bean
    public static PropertySourcesPlaceholderConfigurer placeholderConfigurer() {
        return new PropertySourcesPlaceholderConfigurer();
    }
    
    @Bean("httpClientUtil")
    public HttpClientUtil httpClientUtil() {

       return new HttpClientUtil(100, 2000, 1000);
    }

    @Profile("local")
    @Bean("smsService")
    public ISmsService devSmsService(@Value("${sms.url}") String smsUrl,HttpClientUtil httpClientUtil) {
        //return new SmsLocalService(httpClientUtil()); //通过内部方法引用
    
        return new SmsLocalService(httpClientUtil);
    }
    
    @Profile("prod")
    @Bean("smsService")
    public ISmsService prodSmsService(@Value("${sms.url}") String smsUrl,HttpClientUtil httpClientUtil) {
    
        return new SmsProdService(httpClientUtil);
    }
}
Previous第四章 SpringNext4.2 Spring数据操作框架

Last updated