Spring框架的Bean管理：xml配置实现注入 和 注解实现注入，简述一点纯注解

本篇：

 基于xml方式创建对象

xml配置实现注入：一般属性：（set方法实现 和   构造器方式实现 ）注入，  特殊属性注入。

和

注解方式创建对象

注解实现注入 + 纯注解

------------------------------------------------

1.什么是Bean管理

bean管理指的是这两个操作：1.创建对象， 2.注入属性。

Bean管理操作的两种方式：

1.基于xml配置文件的方式实现， 2.基于注解方式实现。

基于xml配置文件的方式实现Bean管理和注入属性

1.基于xml方式创建对象

：maven 项目创建，pom文件引入依赖

<!--    坐标依赖-->
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.2.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2.编写Spring核心的配置文件，在resources目录下创建applicationContext.xml的配置文件，名称是可以任意的，但是一般都会使用默认名称（applicationContext.xml）。

3.在main 下的java目录下新建一个包，包中创建一个User类，一个Demo类，写点东西测试一下：

Demo类里写一个输出hello的方法，User类里写：

，生成 这几个变量的 set ，get 方法，以及toString方法。

 ，回到配置文件中，配置扫描：

<!--配置扫描-->
    <bean id="demo" class="包.Demo"></bean>
    <!--    配置扫描-->
    <bean id="user" class="包.User"></bean>

test 里写一个 测试 ，注意导入：

public class UserTest {
   @Test
    public void run(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        User user= (User) ac.getBean("user");
        user.hello();
    }
}

2. 基于xml方式注入属性

• 依赖注入的概述

IOC和DI的概念

IOC：Inverse of Control，控制反转，将对象的创建权反转给Spring！！

DI：Dependency Injection，依赖注入，就是注入属性

--------------------------------- 一般变量：

1.属性的set方法注入值

编写属性，提供该属性对应的set方法，编写配置文件完成属性值的注入

.给Uesr 类中的变量赋值：

在配置文件中直接就能赋值，在配置的扫描当中，注意 ！其中demo是我们自己定义的Demo类型

  <!--    配置扫描-->
    <bean id="user" class="com.qcby.User">
            <!--        使用property-->
        <!--        name :类中属性名 value：注入的值-->
        <property name="age" value="18"></property>
        <property name="name" value="小明"></property>
        <!--demo特殊，name：类中属性名  ref：映射 -->
        <property name="demo" ref="demo"></property>
    </bean>

测试

 ----------------------------------------

2.属性构造方法方式注入值

对于类成员变量，构造函数注入。

 User 里写一个构造器:

 配置文件中：

     <constructor-arg name="age" value="19"></constructor-arg>
     <constructor-arg name="name" value="王小明"></constructor-arg>
     <constructor-arg name="demo" ref="demo"></constructor-arg>

 测试类中不变， 运行：

 --------------------------------以上为给一些一般的变量赋值---------------------------------------------

-----------------------------给特殊变量 赋值：数组，List集合 ，map集合

新建CollectionBean类 。生成set，get，toString方法： 

public class CollectionBean {
        public String[] strs;
        private List<String> list;
        private Map<String,String> map; //key，value形式

        public String[] getStrs() {
                return strs;
        }

        public void setStrs(String[] strs) {
                this.strs = strs;
        }

        public List<String> getList() {
                return list;
        }

        public void setList(List<String> list) {
                this.list = list;
        }

        public Map<String, String> getMap() {
                return map;
        }

        public void setMap(Map<String, String> map) {
                this.map = map;
        }

        @Override
        public String toString() {
                return "CollectionBean{" +
                        "strs=" + Arrays.toString(strs) +
                        ", list=" + list +
                        ", map=" + map +
                        '}';
        }
}

配置文件：

<bean id="collection" class="包.CollectionBean"></bean>

 在里面写：

   <bean id="collection" class="包.CollectionBean">
            <property name="strs">
                <array>
                    <value>A</value>
                    <value>B</value>
                    <value>C</value>
                    <value>D</value>
                </array>
            </property>

            <property name="list">
                <list>
                    <value>1</value>
                    <value>2</value>
                    <value>3</value>
                </list>
            </property>

            <property name="map">
                <map>
                    <entry key="aaa" value="111"></entry>
                    <entry key="sss" value="222"></entry>
                    <entry key="ddd" value="333"></entry>
                </map>
            </property>
        </bean>

 test中创建个类 测试一下

public class CollectionTest {
    @Test
    public void run(){
        ApplicationContext ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        CollectionBean collection= (CollectionBean) ac.getBean("collection");
        System.out.println(collection.toString());
    }
}

 

 基于注解的方式实现Bean管理和注入属性

        

1.什么是注解

①：注解是代码特殊标记，格式：@注解名称(属性名称=属性值，属性名称=属性值...)

②：使用注解，注解作用在类上面，方法上面，属性上边

③：使用注解的目的：简化XML配置

2.Spring针对Bean管理中创建对象提供的注解

@Component 普通的类

@Controller 表现层

@Service 业务层

@Repository 持久层

*上边四个功能一样，都可以用来创建bean实例

用注解的方式创建对象

有四个注解都能创建对象，分别是：

• @Component :普通类，
• @Controller：表现层，
• @Service：业务层，
• @Repository：持久层

在Demo类中试试，用哪个也行：

 

配置文件中 配置的扫描不再用<bean>标签，而是：

<!--    扫描注入-->
    <context:component-scan base-package="包"></context:component-scan>

通过扫描注解的方式，实现对类的加载

 test写个类 测试调用一下，还是那样写：

public class DemoTest {
    //spring
    @Test
    public void run1(){
        BeanFactory ac=new ClassPathXmlApplicationContext("applicationContext.xml");
        Demo demo= (Demo) ac.getBean("demo");
        demo.hello();
    }
}

得

实现属性的注入

 User中：

 ，把User类中的构造器删掉或注掉，把配置文件中前边一系列关于User类的 xml形式的注入方式删掉或注掉。

测试类中不变：

得 

看到注解很简单不用怎么配置，但是能不能，完全不用配置文件。连

<!--    扫描注入-->
    <context:component-scan base-package="包"></context:component-scan>

这句话，都不用写。那就是纯注解开发。下方

IOC纯注解的方式

纯注解的方式是微服务架构开发的主要方式，所以也是非常的重要。纯注解的目的是替换掉所有的配置文件。但是需要编写配置类。

常用的注解总结

• @Configuration 声明是配置类
• @ComponentScan 扫描具体包结构的

 小例子：

在 main -->java--->下新建一个包：叫com.config吧,在里边新建 SpringConfig类：编写（写两个注解）：

@Configuration//声明配置类
@ComponentScan(value = "com.qcby")  //扫描具体的包
public class SpringConfig {
    
}

在测试类中写个方法试试：

得，照样可以出来：