Java 将Spring应用程序从XML迁移到注释

我继承了一个Spring3应用程序，它使用XML文件来定义和连接bean。我知道，从Spring2开始，这些基本上可以用注释代替。我想：

• 通过扫描某些包来检测bean，查找带有任何用于指示Springbean的注释的类
• 尝试在我用相关注释标记的bean中按名称和字段自动关联

---

要做到这一点，我需要采取哪些步骤？

我认为首先要做的是放慢速度。只需一次选择一个服务，并在您有理由接触它时迁移它。使用大量的spring配置可以确保您在生产过程中只需要偶尔使用一次依赖项。

本手册提供了您需要的所有信息：

TL；DR版本是，您需要将

添加到spring配置中，然后使用

@组件

注释bean，并在属性设置器中使用

@Autowired

注释bean

我将分别为您提供一个xml配置和一个基于Station的配置等价物，这样您将很容易看到如何将bean从xml更改为java，反之亦然

此文件必须附带此文件

`
包com.mycompany.backendhibernatejpaannotation.configuration；
导入org.springframework.web.servlet.support.AbstractAnnotationConfigDispatchersServletInitializer；
/**
*
*@作者vivien saa
*/
公共类初始值设定项扩展AbstractAnnotationConfigDispatcherServletInitializer{
@凌驾
受保护类[]getRootConfigClasses（）{
返回新类[]{RestConfiguration.Class}；
}
@凌驾
受保护类[]getServletConfigClasses（）{
返回null；
}
@凌驾
受保护的字符串[]getServletMappings（）{
返回新字符串[]{”/“}；
}
}
`

只是补充CarlosZ的答案。如果您正在创建一个新组件，并且希望自动连接一些bean，那么您不必创建getter和setter，只需将@Autowired注释添加到属性声明中，就可以了。正确的@Lucas，您可以执行setter注入、属性注入（不需要setter）或构造函数注入（我个人最喜欢的是，在调用构造函数时，对象应该完全初始化，包括依赖项）。

    `<?xml version="1.0" encoding="UTF-8"?>

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

            <context:component-scan base-package="com.mycompany.backendhibernatejpa.controller" />
            <mvc:annotation-driven />
            <bean id="iAbonneDao" class="com.mycompany.backendhibernatejpa.daoImpl.AbonneDaoImpl"/> 
            <bean id="iAbonneService" class="com.mycompany.backendhibernatejpa.serviceImpl.AbonneServiceImpl"/>

            <!-- couche de persistance JPA -->
            <bean id="entityManagerFactory"
                  class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
                <property name="dataSource" ref="dataSource" />
                <property name="jpaVendorAdapter">
                    <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">            
                        <property name="databasePlatform" value="org.hibernate.dialect.MySQL5InnoDBDialect" />
                        <property name="generateDdl" value="true" />
                        <property name="showSql" value="true" />
                    </bean>
                </property>
                <property name="loadTimeWeaver">
                    <bean
                        class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
                </property>
            </bean>

            <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">   
                <property name="locations" value="classpath:bd.properties"/>
            </bean>

            <!-- la source de donnéees DBCP -->
            <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close" >
                <property name="driverClassName" value="${bd.driver}" />
                <property name="url" value="${bd.url}" />
                <property name="username" value="${bd.username}" />
                <property name="password" value="${bd.password}" />
            </bean>

            <!-- le gestionnaire de transactions -->

            <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
                <property name="entityManagerFactory" ref="entityManagerFactory" />
            </bean>


            <!-- traduction des exceptions -->
            <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor" />

            <!-- annotations de persistance -->
            <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />


        </beans>` 

    ` <web-app> 
             <display-name>Gescable</display-name> 
             <servlet> 
                 <servlet-name>springrest</servlet-name> 
                 <servlet-class> org.springframework.web.servlet.DispatcherServlet </servlet-class> 
                 <load-on-startup>1</load-on-startup> 
             </servlet> 
             <servlet-mapping> 
                 <servlet-name>springrest</servlet-name> 
                 <url-pattern>/</url-pattern> 
             </servlet-mapping> 
         </web-app>`

    `/*
         * To change this license header, choose License Headers in Project Properties.
         * To change this template file, choose Tools | Templates
         * and open the template in the editor.
         */
        package com.mycompany.backendhibernatejpaannotation.configuration;

        import com.mycompany.backendhibernatejpaannotation.daoImpl.AbonneDaoImpl;
        import com.mycompany.backendhibernatejpaannotation.daoInterface.IAbonneDao;
        import com.mycompany.backendhibernatejpaannotation.serviceImpl.AbonneServiceImpl;
        import com.mycompany.backendhibernatejpaannotation.serviceInterface.IAbonneService;
        import javax.sql.DataSource;
        import org.springframework.context.annotation.Bean;
        import org.springframework.context.annotation.ComponentScan;
        import org.springframework.context.annotation.Configuration;
        import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
        import org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver;
        import org.springframework.jdbc.datasource.DriverManagerDataSource;
        import org.springframework.orm.jpa.JpaTransactionManager;
        import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
        import org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor;
        import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
        import org.springframework.web.servlet.config.annotation.EnableWebMvc;

        /**
         *
         * @author vivien saa
         */
        @Configuration
        @EnableWebMvc
        @ComponentScan(basePackages = "com.mycompany.backendhibernatejpaannotation")
        public class RestConfiguration {

            @Bean
            public IAbonneDao iAbonneDao() {
                return new AbonneDaoImpl();
            }

            @Bean
            public IAbonneService iAbonneService() {
                return new AbonneServiceImpl();
            }

        //    @Bean
        //    public PropertyPlaceholderConfigurer placeholderConfigurer() {
        //        PropertyPlaceholderConfigurer placeholderConfigurer = new PropertyPlaceholderConfigurer();
        //        placeholderConfigurer.setLocations("classpath:bd.properties");
        //        return placeholderConfigurer;
        //    }

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

            @Bean
            public HibernateJpaVendorAdapter jpaVendorAdapter() {
                HibernateJpaVendorAdapter jpaVendorAdapter = new HibernateJpaVendorAdapter();
                jpaVendorAdapter.setDatabasePlatform("org.hibernate.dialect.MySQL5InnoDBDialect");
                jpaVendorAdapter.setGenerateDdl(true);
                jpaVendorAdapter.setShowSql(true);
                return jpaVendorAdapter;
            }

            @Bean
            public InstrumentationLoadTimeWeaver loadTimeWeaver() {
                InstrumentationLoadTimeWeaver loadTimeWeaver = new InstrumentationLoadTimeWeaver();
                return loadTimeWeaver;
            }

            @Bean
            public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
                LocalContainerEntityManagerFactoryBean entityManagerFactory = new LocalContainerEntityManagerFactoryBean();
                entityManagerFactory.setDataSource(dataSource());
                entityManagerFactory.setJpaVendorAdapter(jpaVendorAdapter());
                entityManagerFactory.setLoadTimeWeaver(loadTimeWeaver());
                return entityManagerFactory;
            }

            @Bean
            public JpaTransactionManager jpaTransactionManager() {
                JpaTransactionManager jpaTransactionManager = new JpaTransactionManager();
                jpaTransactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
                return jpaTransactionManager;
            }

            @Bean
            public PersistenceExceptionTranslationPostPro`enter code here`cessor persistenceExceptionTranslationPostProcessor() {
                return new PersistenceExceptionTranslationPostProcessor();
            }

            @Bean
            public PersistenceAnnotationBeanPostProcessor persistenceAnnotationBeanPostProcessor() {
                return new PersistenceAnnotationBeanPostProcessor();
            }

        }`

`              
        package com.mycompany.backendhibernatejpaannotation.configuration;

        import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;

        /**
         *
         * @author vivien saa
         */
        public class Initializer extends AbstractAnnotationConfigDispatcherServletInitializer {

            @Override
            protected Class<?>[] getRootConfigClasses() {
                return new Class[]{RestConfiguration.class};
            }

            @Override
            protected Class<?>[] getServletConfigClasses() {
                return null;
            }

            @Override
            protected String[] getServletMappings() {
                return new String[]{"/"};
            }

        }
        `