SpringMVC 基于 XML 和 Java Config 的配置对比

Spring MVC 配置大作战：XML vs. Java Config，谁才是你的菜？

各位看官，欢迎来到 Spring MVC 配置大作战现场！今天我们要聊的不是武林秘籍，而是 Spring MVC 的配置方式。别害怕，这玩意儿虽然听起来有点枯燥，但只要掌握了正确的方法，就能让你的 Web 应用跑得飞起。

我们今天的主角是两位配置界的重量级选手：XML 配置和 Java Config。它们就像两位盖世英雄，一个手持宝剑（XML），古朴典雅；一个身怀绝技（Java Config），灵活多变。到底谁才是你的菜？且听我慢慢道来。

第一回合：出身背景大 PK

XML 配置：老牌贵族，底蕴深厚

XML 配置是 Spring 的老牌配置方式，就像一位经验丰富的管家，帮你把所有的 Bean 都安排得井井有条。它通过 XML 文件描述 Bean 的定义、依赖关系和 AOP 配置等。

优点：

• 历史悠久，资料丰富： 遇到问题，网上随便一搜，答案一大堆。
• 配置集中，易于维护： 所有配置都集中在一个或多个 XML 文件中，方便查看和修改。
• 解耦性强： 代码与配置分离，修改配置无需重新编译代码。

缺点：

• 冗余繁琐： 大量的 XML 标签，写多了眼睛都花了。
• 类型安全弱： XML 配置无法进行编译时类型检查，容易出错。
• 可读性差： 复杂的 XML 配置，让人眼花缭乱。

Java Config：后起之秀，风华正茂

Java Config 是 Spring 3.0 引入的基于 Java 类的配置方式，它就像一位年轻有为的创业者，充满活力和创新精神。它通过 Java 注解和代码来定义 Bean，配置依赖关系和 AOP 等。

优点：

• 类型安全： Java 代码可以进行编译时类型检查，减少出错概率。
• 简洁高效： 使用注解和 Java 代码，配置更简洁，可读性更高。
• 灵活强大： 可以利用 Java 的编程能力，实现更复杂的配置逻辑。

缺点：

• 学习成本： 需要熟悉 Java 注解和 Spring API。
• 代码侵入性： 配置与代码混合，可能增加代码的耦合性。
• 调试难度： 复杂的 Java Config 配置，调试起来可能比较困难。

总结：

特性	XML 配置	Java Config
出身背景	老牌贵族，底蕴深厚	后起之秀，风华正茂
配置方式	XML 文件	Java 类 + 注解
类型安全	弱	强
简洁性	冗余繁琐	简洁高效
可读性	较差	较好
灵活性	较差	较好
学习成本	低	较高
适用场景	中小型项目，配置简单，追求解耦	大型项目，配置复杂，追求效率

第二回合：配置实战大比拼

接下来，我们通过一些实际的例子，来对比一下 XML 配置和 Java Config 的用法。

1. 配置 DispatcherServlet

XML 配置：

在 web.xml 中配置 DispatcherServlet：

<servlet>
    <servlet-name>dispatcher</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>/WEB-INF/spring/dispatcher-servlet.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>

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

然后在 dispatcher-servlet.xml 中配置 Spring MVC：

<context:component-scan base-package="com.example.controller"/>

<mvc:annotation-driven/>

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <property name="prefix" value="/WEB-INF/views/"/>
    <property name="suffix" value=".jsp"/>
</bean>

Java Config：

创建一个配置类，使用 @Configuration 注解标记：

@Configuration
@EnableWebMvc
@ComponentScan("com.example.controller")
public class WebConfig implements WebMvcConfigurer {

    @Bean
    public ViewResolver viewResolver() {
        InternalResourceViewResolver resolver = new InternalResourceViewResolver();
        resolver.setPrefix("/WEB-INF/views/");
        resolver.setSuffix(".jsp");
        return resolver;
    }

    @Override
    public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
        configurer.enable();
    }
}

然后，在 WebApplicationInitializer 中注册 DispatcherServlet 和配置类：

public class WebAppInitializer implements WebApplicationInitializer {

    @Override
    public void onStartup(ServletContext servletContext) throws ServletException {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(WebConfig.class);
        context.setServletContext(servletContext);

        DispatcherServlet dispatcher = new DispatcherServlet(context);
        ServletRegistration.Dynamic registration = servletContext.addServlet("dispatcher", dispatcher);
        registration.setLoadOnStartup(1);
        registration.addMapping("/");
    }
}

对比：

• XML 配置需要在 web.xml 和 dispatcher-servlet.xml 中进行配置，比较繁琐。
• Java Config 只需要一个配置类和一个 WebApplicationInitializer，更加简洁。
• @EnableWebMvc 相当于 XML 配置中的 <mvc:annotation-driven/>，启用了 Spring MVC 的默认配置。
• @ComponentScan 相当于 XML 配置中的 <context:component-scan/>，扫描指定包下的组件。
• ViewResolver 的配置方式类似，都是通过定义一个 Bean 来实现。

2. 配置 Bean

XML 配置：

<bean id="userService" class="com.example.service.UserServiceImpl">
    <property name="userDao" ref="userDao"/>
</bean>

<bean id="userDao" class="com.example.dao.UserDaoImpl">
    <property name="dataSource" ref="dataSource"/>
</bean>

<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/mydb"/>
    <property name="username" value="root"/>
    <property name="password" value="password"/>
</bean>

Java Config：

@Configuration
public class AppConfig {

    @Bean
    public UserService userService(UserDao userDao) {
        return new UserServiceImpl(userDao);
    }

    @Bean
    public UserDao userDao(DataSource dataSource) {
        return new UserDaoImpl(dataSource);
    }

    @Bean
    public DataSource dataSource() {
        DriverManagerDataSource dataSource = new DriverManagerDataSource();
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
        dataSource.setUsername("root");
        dataSource.setPassword("password");
        return dataSource;
    }
}

对比：

• XML 配置使用 <bean> 标签定义 Bean，使用 <property> 标签注入依赖。
• Java Config 使用 @Bean 注解定义 Bean，通过方法参数注入依赖。
• Java Config 的依赖注入更加直观，可以直接在方法参数中声明依赖的 Bean。

3. 配置 AOP

XML 配置：

<aop:config>
    <aop:pointcut id="serviceMethods" expression="execution(* com.example.service.*.*(..))"/>
    <aop:aspect ref="loggingAspect">
        <aop:before pointcut-ref="serviceMethods" method="beforeAdvice"/>
        <aop:after-returning pointcut-ref="serviceMethods" method="afterReturningAdvice" returning="retVal"/>
        <aop:after-throwing pointcut-ref="serviceMethods" method="afterThrowingAdvice" throwing="ex"/>
        <aop:after pointcut-ref="serviceMethods" method="afterAdvice"/>
    </aop:aspect>
</aop:config>

<bean id="loggingAspect" class="com.example.aspect.LoggingAspect"/>

Java Config：

@Configuration
@EnableAspectJAutoProxy
public class AopConfig {

    @Bean
    public LoggingAspect loggingAspect() {
        return new LoggingAspect();
    }
}

@Aspect
@Component
public class LoggingAspect {

    @Before("execution(* com.example.service.*.*(..))")
    public void beforeAdvice() {
        System.out.println("Before method execution");
    }

    @AfterReturning(pointcut = "execution(* com.example.service.*.*(..))", returning = "retVal")
    public void afterReturningAdvice(Object retVal) {
        System.out.println("After returning: " + retVal);
    }

    @AfterThrowing(pointcut = "execution(* com.example.service.*.*(..))", throwing = "ex")
    public void afterThrowingAdvice(Throwable ex) {
        System.out.println("After throwing: " + ex);
    }

    @After("execution(* com.example.service.*.*(..))")
    public void afterAdvice() {
        System.out.println("After method execution");
    }
}

对比：

• XML 配置使用 <aop:config> 标签配置 AOP，使用 <aop:pointcut> 定义切点，使用 <aop:aspect> 定义切面。
• Java Config 使用 @EnableAspectJAutoProxy 启用 AOP，使用 @Aspect 注解定义切面，使用 @Before、@AfterReturning、@AfterThrowing、@After 等注解定义通知。
• Java Config 的 AOP 配置更加简洁，可以直接在方法上使用注解，可读性更高。

第三回合：混合配置，左右逢源

其实，XML 配置和 Java Config 并不是非此即彼的关系，我们可以将它们混合使用，取长补短。

例如：

• 使用 Java Config 配置主要的 Bean，使用 XML 配置一些第三方 Bean。
• 使用 XML 配置一些通用的配置，使用 Java Config 配置一些特殊的配置。

示例：

在 Java Config 中引入 XML 配置文件：

@Configuration
@ImportResource("classpath:applicationContext.xml")
public class AppConfig {

    // ...
}

在 XML 配置文件中引入 Java Config 类：

<bean class="com.example.config.AppConfig"/>

总结：

混合配置可以让我们充分利用 XML 配置和 Java Config 的优点，实现更加灵活和高效的配置。

第四回合：最佳实践，避免踩坑

在实际开发中，我们应该遵循一些最佳实践，避免踩坑。

• 保持配置的简洁性： 尽量使用简洁的配置方式，避免过度配置。
• 选择合适的配置方式： 根据项目的规模和复杂程度，选择合适的配置方式。
• 使用统一的命名规范： 保持配置文件的命名规范一致，方便维护。
• 添加注释： 在配置文件中添加必要的注释，方便理解和维护。
• 定期审查配置： 定期审查配置，清理冗余配置，优化配置性能。

最终总结：

XML 配置和 Java Config 都有各自的优缺点，选择哪种配置方式取决于你的具体需求和偏好。

• 如果你喜欢传统的配置方式，追求代码与配置分离，可以选择 XML 配置。
• 如果你喜欢简洁高效的配置方式，追求类型安全和灵活性，可以选择 Java Config。
• 如果你想充分利用两种配置方式的优点，可以选择混合配置。

无论你选择哪种配置方式，都要记得保持配置的简洁性和可读性，避免过度配置，定期审查配置，才能让你的 Spring MVC 应用跑得更稳、更快、更好！

希望这篇文章能帮助你更好地理解 Spring MVC 的配置方式，并在实际开发中做出明智的选择。祝你编码愉快！