使用Spring框架入门二：基于注解+XML配置的IOC/DI的使用

一、简述

本文主要讲使用注解+xml配合使用的几种使用方式。基础课程请看前一节。

二、步骤

1、为Pom.xml中引入依赖：本例中使用的是spring-context包，引入此包时系统会自动导入它的依赖包spring-beans\spring-core\spring-expression\spring-context.

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>sindrol</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.0.5.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>
    </dependencies>
</project>

2、在/src/java/test2下建立下列类：

package test2;

import lombok.Data;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Controller;
import org.springframework.stereotype.Repository;
import org.springframework.stereotype.Service;

@Data
@Component(value = "product1")
//@Controller("product1") //Controller也是一个Component，一般用于WEB中的Action
//@Service("product1")//Service也是一个Component，一般用于业务逻辑类
//@Repository("product1")//Repository也是一个Component，一般用于持久层类
public class Product {
    @Value("Sindrol")
    private String name;
    @Value("1.5")
    private float price;
}
package test2;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service("productOperate")
public class ProductOperate {
    //使用Resource也可以实现值的注入，使用Resource和Autowired的区别在于，Resource可以指定的名称必须和要注入Comment名称相同的对象，名称不一致时出错。
    @Resource(name = "product1")
    private Product product;
    @Autowired
    private Product product2;

    @Override
    public String toString() {
        return "ProductOperate(product=" + product + " ,product2=" + product2 + ")";
    }
}
package test2;

import jdk.nashorn.internal.objects.annotations.Constructor;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.context.annotation.ScopedProxyMode;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.PrimitiveIterator;

@Data
@Component("paramProduct1")
//@Scope("prototype")
@Scope("singleton")
public class ParamProduct {
    @Value("JAVA书集")
    private String name;
    private float price;
    private Product product;

    public ParamProduct(@Autowired Product product, @Value("Sindrol") String name, @Value("28") float price) {
        this.product = product;
        this.name = name;
        this.price = price;
    }

}
package test2;

import java.util.List;

public class ConstructProduct {
    private List<String> list;

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

    @Override
    public String toString() {
        return "ConstructProduct(list=" + list + ")";
    }
}
package test2;

import org.springframework.context.annotation.ComponentScan;

//使用ComponentScan定义类所在包开头名称。
@ComponentScan(basePackages = "test2")
public class SamePackage {
}

3、在/src/test/resources（注意：标记此resources为测试资源）下建立applicationContextTest2.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <!--开启注解扫描（扫描test2开头的包）-->
    <context:component-scan base-package="test2"/>

    <!--引入配置文件，引入后值中可使用变量。引入方法一：-->
    <!--<context:property-placeholder location="config.properties" file-encoding="UTF-8"/>-->
    <!--引入配置文件，引入后值中可使用变量。引入方法二：-->
    <bean id="propertyConfigurer"
          class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location" value="config.properties" />
        <property name="fileEncoding" value="UTF-8"/>
    </bean>

    <!--扫描属性上面的注解-->
    <!--<context:annotation-config></context:annotation-config>-->
    <bean id="constructProduct" class="test2.ConstructProduct">
        <constructor-arg>
            <array>
                <!--这里可以使用引入的properties文件的变量 -->
                <value>${configKey1}</value>
                <value>${configKey2}</value>
                <value>list_item3</value>
            </array>
        </constructor-arg>
    </bean>
</beans>

4、在/src/test/resources下建立一个名为config.properties的文件，内容如下：（这里一定要注意文件的编码，IDEA在Windows下默认新建的properties是ASCII编码，所以要转成UTF-8编码后测试。）

#这是Key:Value结构。
configKey1:this is my value1.
configKey2:柱柱

5、在/src/test/java/BeanTest下添加Junit测试方法:

import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import test1.Student;
import test1.User;
import test2.*;
import test3.Bird;

public class BeanTest {

    @Test
    public void test2() {
        //ApplicationContext context = new AnnotationConfigApplicationContext(SamePackage.class);
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextTest2.xml");
        Product product1 = (Product) context.getBean("product1");
        System.out.println(product1);
    }

    @Test
    public void test3() {
        ApplicationContext context = new AnnotationConfigApplicationContext(SamePackage.class);
        ParamProduct paramProduct1 = (ParamProduct) context.getBean(ParamProduct.class, new Object[]{ //构造函数值
                context.getBean(Product.class),
                "Product初始名字",
                23
        });
        System.out.println(paramProduct1);
        ParamProduct paramProduct2 = (ParamProduct) context.getBean(ParamProduct.class, new Object[]{ //构造函数值
                context.getBean(Product.class),
                "Product初始名字2",
                333
        });
        System.out.println(paramProduct2); //注意，paramProduct2并未进行真实的构造，而是直接取了单例对象。
        System.out.println("是否是同一实例：" + (paramProduct1 == paramProduct1));
    }

    @Test
    public void test4() {
        ApplicationContext context = new AnnotationConfigApplicationContext(SamePackage.class);
        ProductOperate productOperate = context.getBean(ProductOperate.class);
        System.out.println(productOperate);
    }

    @Test
    public void test5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextTest2.xml");
        ConstructProduct constructProduct = context.getBean(ConstructProduct.class);
        System.out.println(constructProduct);
    }

}

6、执行测试，查看测试结果：

test2测试结果：

Product(name=Sindrol, price=1.5)

test3测试结果：

五月 06, 2018 12:40:40 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.spring[email protected]10e92f8f: startup date [Sun May 06 12:40:40 CST 2018]; root of context hierarchy
ParamProduct(name=JAVA书集, price=28.0, product=Product(name=Sindrol, price=1.5))
ParamProduct(name=JAVA书集, price=28.0, product=Product(name=Sindrol, price=1.5))
是否是同一实例：true

test4测试结果：

五月 06, 2018 12:40:40 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org.spring[email protected]67a20f67: startup date [Sun May 06 12:40:40 CST 2018]; root of context hierarchy
五月 06, 2018 12:40:40 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org[email protected]31368b99: startup date [Sun May 06 12:40:40 CST 2018]; root of context hierarchy
五月 06, 2018 12:40:40 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContextTest2.xml]
ProductOperate(product=Product(name=Sindrol, price=1.5) ,product2=Product(name=Sindrol, price=1.5))

test5测试结果：

ConstructProduct(list=[this is my value1., 柱柱, list_item3])

三、测试属性文件以Map的形式载入

1、在/src/test/java/test3下建立一个Bird类

package test3;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class Bird {
    @Value("#{configProperties[‘configKey2‘]}")
    private String configKey2;
    @Value("#{configProperties}")
    private Map<String, String> properties;

    @Override
    public String toString() {
        return "Bird(properties=" + properties + ",configKey2=" + configKey2 + ")";
    }
}

2、在/src/test/resources下建立一个applicationContextTest3.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:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="test3"/>
    <bean id="configProperties" class="org.springframework.beans.factory.config.PropertiesFactoryBean">
        <property name="locations">
            <list>
                <value>*.properties</value>
            </list>
        </property>
        <property name="fileEncoding" value="UTF-8"/>
    </bean>
</beans>

3、在/src/test/java/BeanTest中添加test6测试方法：

    @Test
    public void test6() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContextTest3.xml");
        Bird bird = context.getBean(Bird.class);
        System.out.println(bird);
    }

4、运行查看结果：

五月 06, 2018 12:40:41 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh
信息: Refreshing org[email protected]795cd85e: startup date [Sun May 06 12:40:41 CST 2018]; root of context hierarchy
五月 06, 2018 12:40:41 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [applicationContextTest3.xml]
Bird(properties={configKey1=this is my value1., #这是Key=Value结构。, configKey2=柱柱},configKey2=柱柱)

原文地址：https://www.cnblogs.com/songxingzhu/p/8997922.html

时间： 2024-10-31 01:52:53

使用Spring框架入门二：基于注解+XML配置的IOC/DI的使用的相关文章

使用Spring框架入门一：基于XML配置的IOC/DI的使用

一.Spring框架 1.方法一:逐项导入基础依赖包: spring-core.spring-beans.spring-context.spring-expression 2.方法二:最简洁的导入,直接导入spring-context包: <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version&g

spring学习2:基于注解+xml实现ioc和依赖注入

spring学习2:基于注解+xml实现ioc和依赖注入 一.在spring配置文件中开启spring对注解的支持 <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance&qu

Spring框架bean的配置（3）：基于注解的配置，Autowired 自动装配 Bean，泛型依赖注入

1.基于注解的配置: @Component: 基本注解, 标识了一个受 Spring 管理的组件 @Respository: 标识持久层组件 @Service: 标识服务层(业务层)组件 @Controller: 标识表现层组件 建立接口:UserRepository package com.atguigu.spring.beans.annotation.test; public interface UserRepository { void save(); } 建立类:UserReposito

(spring-第4回)spring基于注解的配置

基于XML的bean属性配置:bean的定义信息与bean的实现类是分离的. 基于注解的配置:bean的定义信息是通过在bean实现类上标注注解实现. 也就是说,加了注解,相当于在XML中配置了,一样一样的. 一.举个栗子: 1 package com.mesopotamia.annotation; 2 3 import org.springframework.stereotype.Component; 4 5 @Component 6 public class Car { 7 private

【Spring】IOC之基于注解的配置bean

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 一.基于注解的配置 Spring 2.5 中除了提供 @Component 注释外,还定义了几个拥有特殊语义的注释,它们分别是:@Repository.@Service 和 @Controller.在目前的 Spring 版本中,这 3 个注释和 @Component 是等效的,但是从注释类的命名上,很容易看出这 3 个注释分别和持久层.业务层和控制层(Web 层)相对应.虽然目前这3 个注

Spring MVC 中的基于注解的 Controller【转】

原文地址:http://my.oschina.net/abian/blog/128028 终于来到了基于注解的 Spring MVC 了.之前我们所讲到的 handler,需要根据 url 并通过 HandlerMapping 来映射出相应的 handler 并调用相应的方法以响应请求.实际上,ControllerClassNameHandlerMapping, MultiActionController 和选择恰当的 methodNameResolver(如 InternalPathMetho

spring学习5：基于注解实现spring的aop

目录 spring学习5:基于注解实现spring的aop 一.基于注解+xml实现 1.1 在配置文件中开启spring对注解aop的支持 1.2 把通知类用注解配置到容器中,并用注解声明为切面 1.3 定义切入点表达式 1.4 定义通知 二.基于纯注解实现 三.多个aop的执行顺序 1.xml配置 2.注解配置 3.注意 spring学习5:基于注解实现spring的aop 上一节学习了spring aop的基本概念和如何基于xml配置来实现aop功能.这一节来学习下如何用注解实现aop 一

Java - Struts框架教程 Hibernate框架教程 Spring框架入门教程（新版） sping mvc spring boot spring cloud Mybatis

https://www.zhihu.com/question/21142149 http://how2j.cn/k/hibernate/hibernate-tutorial/31.html?tid=63 https://www.zhihu.com/question/29444491/answer/146457757 1. Java - Struts框架教程Struts 是Apache软件基金会(ASF)赞助的一个开源项目.通过采用JavaServlet/JSP技术,实现了基于Java EEWeb

IOC之基于注解的配置讲解

林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 从Spring2.0以后的版本中,Spring也引入了基于注解(Annotation)方式的配置,注解(Annotation)是JDK1.5中引入的一个新特性,用于简化Bean的配置,某些场合可以取代XML配置文件.开发人员对注解(Annotation)的态度也是萝卜青菜各有所爱,个人认为注解可以大大简化配置,提高开发速度,同时也不能完全取代XML配置方式,XML方式更加灵活,并且发展的相对