spring不使用注解怎么注入

要在Spring中进行依赖注入，除了使用注解之外还有其他的方式可以实现。下面列举了两种常见的方式来实现Spring的依赖注入，不使用注解的方法。

一、XML配置方式
在XML配置文件中配置Bean，并配置其依赖关系。以下是一个简单的示例：

1. 创建一个Java类作为被注入的类，例如：

public class UserDao {
    // ...
}

2. 在XML配置文件中定义Bean并配置其依赖关系，例如：

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

    <bean id="userDao" class="com.example.UserDao">
        <!-- 配置依赖注入 -->
    </bean>
</beans>

3. 在其他类中使用依赖注入，例如：

public class UserService {
    private UserDao userDao;

    // 使用setter方法进行注入
    public void setUserDao(UserDao userDao) {
        this.userDao = userDao;
    }

    // ...
}

二、Java配置方式
除了XML配置方式，Spring还提供了Java配置方式来实现依赖注入。以下是一个简单的示例：

1. 创建一个Java类作为被注入的类，例如：

public class UserDao {
    // ...
}

2. 创建一个配置类并使用@Configuration注解，例如：

@Configuration
public class AppConfig {
    @Bean
    public UserDao userDao() {
        return new UserDao();
    }

    // ...
}

3. 在其他类中使用依赖注入，例如：

public class UserService {
    private UserDao userDao;

    // 使用构造方法进行注入
    public UserService(UserDao userDao) {
        this.userDao = userDao;
    }

    // ...
}

以上是两种不使用注解的方式进行Spring的依赖注入。无论是使用XML配置方式还是Java配置方式，都需要在配置文件或配置类中定义Bean并配置其依赖关系。通过这种方式，可以在不使用注解的情况下实现Spring的依赖注入。

在Spring框架中，除了使用注解来实现依赖注入（DI）外，还可以使用XML配置文件来进行注入。下面是详细的步骤：

1. 创建一个XML配置文件，用于定义bean和依赖关系。可以使用<bean>元素来定义bean，并使用<property>元素来定义依赖关系。例如：

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

    <bean id="myDependency" class="com.example.MyDependency" />

    <bean id="myBean" class="com.example.MyBean">
        <property name="dependency" ref="myDependency" />
    </bean>
    
</beans>

2. 在代码中加载XML配置文件，并使用ApplicationContext接口提供的方法获取bean。

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyApp {
    public static void main(String[] args) {
        // 加载XML配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        
        // 获取bean
        MyBean myBean = context.getBean("myBean", MyBean.class);
        
        // 使用bean
        myBean.doSomething();
    }
}

注意，上述代码中的applicationContext.xml是在类路径下的XML配置文件。如果配置文件位于其他位置，需要相应地修改加载配置文件的代码。

3. 在bean类中定义成员变量并提供相应的getter和setter方法。

public class MyBean {
    private MyDependency dependency;

    public MyDependency getDependency() {
        return dependency;
    }

    public void setDependency(MyDependency dependency) {
        this.dependency = dependency;
    }

    public void doSomething() {
        // 使用依赖
        dependency.doSomething();
    }
}

4. 如果需要注入其他bean的属性，可以通过设置相应的setter方法来实现。

public class MyBean {
    private MyDependency dependency;
    private String name;

    public MyDependency getDependency() {
        return dependency;
    }

    public void setDependency(MyDependency dependency) {
        this.dependency = dependency;
    }

    public String getName() {
        return name;
    }

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

    public void doSomething() {
        // 使用依赖和name
        dependency.doSomething();
        System.out.println("Hello, " + name);
    }
}

在XML配置文件中，可以使用<property>元素来设置name属性：

<bean id="myBean" class="com.example.MyBean">
    <property name="dependency" ref="myDependency" />
    <property name="name" value="Alice" />
</bean>

这样，当myBean.doSomething()被调用时，会输出"Hello, Alice"。

5. 最后，在执行的时候，记得引入相关的Spring依赖，以便可以使用Spring提供的类库。

以上就是使用XML配置文件进行依赖注入的步骤。虽然使用注解更加方便和灵活，但XML配置文件的方式在一些特定的场景下仍然被广泛使用。

在Spring中，我们可以使用注解来实现依赖注入，但是如果你不想使用注解，仍然可以通过传统的方式来实现依赖注入。下面我将介绍一下如何在Spring中实现不使用注解的依赖注入。

步骤一：配置bean
首先，在Spring的配置文件中定义需要注入的bean。可以使用XML文件配置bean，如下所示：

<bean id="myBean" class="com.example.MyBean"/>
<bean id="anotherBean" class="com.example.AnotherBean">
    <property name="myBean" ref="myBean"/>
</bean>

在上面的例子中，我们定义了两个bean：myBean和anotherBean。anotherBean需要注入myBean作为其依赖。

步骤二：实现类
接着，创建相应的实现类，实现依赖注入。示例代码如下：

public class MyBean {
    //...
}

public class AnotherBean {
    private MyBean myBean;

    // setter方法
    public void setMyBean(MyBean myBean) {
        this.myBean = myBean;
    }
}

在上面的例子中，我们在AnotherBean类中定义了一个成员变量myBean，并提供了一个setter方法来实现对myBean的注入。

步骤三：获取bean
最后，我们需要在应用程序中获取被注入的bean。可以使用ApplicationContext来获取bean，示例代码如下：

public class MyApp {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        AnotherBean anotherBean = context.getBean("anotherBean", AnotherBean.class);
        // 使用anotherBean...
    }
}

在上面的例子中，我们使用ClassPathXmlApplicationContext来获取ApplicationContext对象，然后使用getBean方法获取anotherBean。

通过上面的三个步骤，我们就可以在Spring中实现不使用注解的依赖注入。