Spring从入门到入土(bean的一些子标签及注解的使用)

简介: 本文详细介绍了Spring框架中Bean的创建和使用,包括使用XML配置文件中的标签和注解来创建和管理Bean,以及如何通过构造器、Setter方法和属性注入来配置Bean。

类目录结构

public class Cpu {
    private Integer num;
    private String cpuName;
    private String factory;

    public Cpu() {
    }

    public Cpu(Integer num, String cpuName, String factory) {
        this.num = num;
        this.cpuName = cpuName;
        this.factory = factory;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public void setCpuName(String cpuName) {
        this.cpuName = cpuName;
    }

    public void setFactory(String factory) {
        this.factory = factory;
    }

    @Override
    public String toString() {
        return "Cpu{" +
                "num=" + num +
                ", cpuName='" + cpuName + '\'' +
                ", factory='" + factory + '\'' +
                '}';
    }
}
public class Computer {
    private Integer num;
    private String computerName;
    private Cpu cpu;

    public Computer() {
    }

    public Computer(Integer num, String computerName, Cpu cpu) {
        this.num = num;
        this.computerName = computerName;
        this.cpu = cpu;
    }

    public void setNum(Integer num) {
        this.num = num;
    }

    public void setComputerName(String computerName) {
        this.computerName = computerName;
    }

    public void setCpu(Cpu cpu) {
        this.cpu = cpu;
    }

    @Override
    public String toString() {
        return "Computer{" +
                "num=" + num +
                ", computerName='" + computerName + '\'' +
                ", cpu=" + cpu +
                '}';
    }
}
public class SuperComputer {
    private String[] computerNames;
    private List<String> factorys;
    private Set<Cpu> cpus;
    private Map<Integer,String> users;
    private Properties userGirls;

    public void setComputerNames(String[] computerNames) {
        this.computerNames = computerNames;
    }

    public void setFactorys(List<String> factorys) {
        this.factorys = factorys;
    }

    public void setCpus(Set<Cpu> cpus) {
        this.cpus = cpus;
    }

    public void setUsers(Map<Integer, String> users) {
        this.users = users;
    }

    public void setUserGirls(Properties userGirls) {
        this.userGirls = userGirls;
    }

    @Override
    public String toString() {
        return "SuperComputer{" +
                "computerNames=" + Arrays.toString(computerNames) +
                ", factorys=" + factorys +
                ", cpus=" + cpus +
                ", users=" + users +
                ", userGirls=" + userGirls +
                '}';
    }
}
<?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 
       https://www.springframework.org/schema/context/spring-context.xsd">
</beans>

1. 使用无参构造创建对象

在xml文件中加入

<bean id="cpu" class="org.example.IOC.Cpu"></bean>
    @Test
    public void cpuTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        Cpu bean1 = (Cpu) context.getBean("cpu");
        System.out.println(bean1);

    }

2. 使用有参构造创建对象

    <bean id="cpu" class="org.example.IOC.Cpu">
        <!-- 通过类型定位属性-->
        <constructor-arg type="java.lang.Integer" value="123"></constructor-arg>
        <!--通过下标定位属性-->
        <constructor-arg index="1" value="Inter"></constructor-arg>
        <!--通过属性名定位属性-->
        <constructor-arg name="factory" value="InterFactory"></constructor-arg>
    </bean>
    @Test
    public void cpuTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        Cpu bean1 = (Cpu) context.getBean("cpu");
        System.out.println(bean1);

    }

3. 带有类类型属性的构造器创建对象

   @Test
    public void cpuTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        Computer computer = (Computer) context.getBean("computer");
        System.out.println(computer);
    }
    <bean id="cpu" class="org.example.IOC.Cpu">
        <!-- 通过类型定位属性-->
        <constructor-arg type="java.lang.Integer" value="123"></constructor-arg>
        <!--通过下标定位属性-->
        <constructor-arg index="1" value="Inter"></constructor-arg>
        <!--通过属性名定位属性-->
        <constructor-arg name="factory" value="InterFactory"></constructor-arg>
    </bean>
    <!--构造器方法赋值-->
    <bean id="computer" class="org.example.IOC.Computer">
        <constructor-arg name="num" value="100"></constructor-arg>
        <constructor-arg name="computerName" value="外星人"></constructor-arg>
        <constructor-arg name="cpu" ref="cpu"></constructor-arg>
    </bean>

    <bean id="computer" class="org.example.IOC.Computer">
        <constructor-arg name="num" value="100"></constructor-arg>
        <constructor-arg name="computerName" value="外星人"></constructor-arg>
        <constructor-arg name="cpu">
            <bean class="org.example.IOC.Cpu">
                <constructor-arg type="java.lang.Integer" value="666"></constructor-arg>
                <constructor-arg index="1" value="Inter"></constructor-arg>
                <constructor-arg name="factory" value="InterFactory"></constructor-arg>
            </bean>
        </constructor-arg>
    </bean>

4. 使用Set方法传递参数

    @Test
    public void cpuTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        Computer computer1 = (Computer) context.getBean("computer1");
        System.out.println(computer1);
    }
    <bean id="cpu" class="org.example.IOC.Cpu">
        <!-- 通过类型定位属性-->
        <constructor-arg type="java.lang.Integer" value="123"></constructor-arg>
        <!--通过下标定位属性-->
        <constructor-arg index="1" value="Inter"></constructor-arg>
        <!--通过属性名定位属性-->
        <constructor-arg name="factory" value="InterFactory"></constructor-arg>
    </bean>
    <!--Set方法传参数-->
    <bean id="computer1" class="org.example.IOC.Computer">
        <!--name: 指定set方法   value: 传入的值-->
        <property name="num" value="200"></property>
        <property name="computerName" value="苹果"></property>
        <!--ref: 引用spring容器中的对象-->
        <property name="cpu" ref="cpu"></property>
    </bean>

5. 集合, 数组的参数传递

    @Test
    public void cpuTest(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        SuperComputer superComputer = (SuperComputer) context.getBean("superComputer");
        System.out.println(superComputer);
    }
   <bean id="superComputer" class="org.example.IOC.SuperComputer">
        <property name="computerNames">
            <array>
                <value>MacPro</value>
                <value>外星人</value>
            </array>
        </property>

        <property name="factorys">
            <list>
                <value>因特尔工厂</value>
                <value>苹果工厂</value>
            </list>
        </property>

        <property name="cpus">
            <set>
                <bean class="org.example.IOC.Cpu">
                    <constructor-arg name="num" value="111"></constructor-arg>
                    <constructor-arg name="cpuName" value="Inter"></constructor-arg>
                    <constructor-arg name="factory" value="因特尔工厂"></constructor-arg>
                </bean>
                <bean class="org.example.IOC.Cpu">
                    <constructor-arg name="num" value="222"></constructor-arg>
                    <constructor-arg name="cpuName" value="苹果"></constructor-arg>
                    <constructor-arg name="factory" value="苹果工厂"></constructor-arg>
                </bean>
            </set>
        </property>

        <property name="users">
            <map>
                <entry key="1" value="张三"></entry>
                <entry key="2" value="李四"></entry>
            </map>
        </property>

        <property name="userGirls">
            <props>
                <prop key="1">貂蝉</prop>
                <prop key="2">西施</prop>
            </props>
        </property>
    </bean>

6. 注解的使用

    <!--扫描整个包-->
    <context:component-scan base-package="org.example.IOC"></context:component-scan>

6.1 类注解的使用

    **@Component
    @Service        业务层
    @Controller     表现层
    @Repository     持久层**
//@Component(value = "cpu")
@Component     //默认id: 类名首字母小写

//@Service(value = "cpu")
//@Service

//@Controller(value = "cpu")
//@Controller

//@Repository(value = "cpu")
//@Repository

public class Cpu {
    private Integer num;
    private String cpuName;
    private String factory;

   //...此处省略(与上方对应类代码相同)
}
  @Test
    public void Test02(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        //注解的使用
        Cpu bean = (Cpu) context.getBean("cpu");
        System.out.println(bean);
    }

6.1 @Value注解的使用

@Component     //默认id: 类名首字母小写
public class Cpu {
    @Value("666")
    private Integer num;
    @Value("因特尔")
    private String cpuName;
    @Value("InterFactory")
    private String factory;

    //....此处省略(与上面代码一样)
}

6.2 类类型属性注解的使用

@Autowired
@Qualifier(value = "cpu")

@Resource(name = "cpu")
@Component
public class Computer {
    private Integer num;
    private String computerName;
    @Autowired
    @Qualifier(value = "cpu")

    //@Resource(name = "cpu")
    private Cpu cpu;

   //...此处省略(与上方对应类代码相同)
}

6.3 单例多例注解的使用

@Scope(value = ConfigurableBeanFactory.SCOPE_SINGLETON)  //单例
@Scope(value = ConfigurableBeanFactory.SCOPE_PROTOTYPE)  //多例
public class Computer {
    ......
}

6.4 @PostConstruct和@PreDestroy注解的使用

@Component
public class Computer {
    private Integer num;
    private String computerName;
    @Autowired
    @Qualifier(value = "cpu")
    private Cpu cpu;

    //...此处省略(与上方对应类代码相同)

//创建容器时调用
    @PostConstruct
    public void initMethod(){
        System.out.println("容器被创建!");
    }
//销毁容器时调用
    @PreDestroy
    public void destroyMethod(){
        System.out.println("容器被销毁!");
    }
}
   @Test
    public void Test02(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        ((ClassPathXmlApplicationContext)context).close();
    }

单例模式下:

6.5 通过字节码获取对象

  @Test
    public void Test02(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("spring_bean.xml");

        //通过字节码拿到对象
        //缺点: 当配置了多个bean时, 因为字节码是相同的,因此会造成混淆(不知道给你返回哪一个bean)
        Cpu bean = context.getBean(Cpu.class);
        System.out.println(bean);
    }

相关文章
|
17天前
|
XML Java 数据格式
SpringBoot入门(8) - 开发中还有哪些常用注解
SpringBoot入门(8) - 开发中还有哪些常用注解
36 0
|
2月前
|
Java Spring
在使用Spring的`@Value`注解注入属性值时,有一些特殊字符需要注意
【10月更文挑战第9天】在使用Spring的`@Value`注解注入属性值时,需注意一些特殊字符的正确处理方法,包括空格、引号、反斜杠、新行、制表符、逗号、大括号、$、百分号及其他特殊字符。通过适当包裹或转义,确保这些字符能被正确解析和注入。
|
20天前
|
缓存 Java Spring
实战指南:四种调整 Spring Bean 初始化顺序的方案
本文探讨了如何调整 Spring Boot 中 Bean 的初始化顺序,以满足业务需求。文章通过四种方案进行了详细分析: 1. **方案一 (@Order)**:通过 `@Order` 注解设置 Bean 的初始化顺序,但发现 `@PostConstruct` 会影响顺序。 2. **方案二 (SmartInitializingSingleton)**:在所有单例 Bean 初始化后执行额外的初始化工作,但无法精确控制特定 Bean 的顺序。 3. **方案三 (@DependsOn)**:通过 `@DependsOn` 注解指定 Bean 之间的依赖关系,成功实现顺序控制,但耦合性较高。
实战指南:四种调整 Spring Bean 初始化顺序的方案
|
24天前
|
XML JSON Java
SpringBoot必须掌握的常用注解!
SpringBoot必须掌握的常用注解!
45 4
SpringBoot必须掌握的常用注解!
|
2天前
|
前端开发 Java Spring
探索Spring MVC:@Controller注解的全面解析
在Spring MVC框架中,`@Controller`注解是构建Web应用程序的基石之一。它不仅简化了控制器的定义,还提供了一种优雅的方式来处理HTTP请求。本文将全面解析`@Controller`注解,包括其定义、用法、以及在Spring MVC中的作用。
17 2
|
26天前
|
存储 缓存 Java
Spring缓存注解【@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig】使用及注意事项
Spring缓存注解【@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig】使用及注意事项
81 2
|
26天前
|
JSON Java 数据库
SpringBoot项目使用AOP及自定义注解保存操作日志
SpringBoot项目使用AOP及自定义注解保存操作日志
36 1
|
2月前
|
Java 测试技术 Windows
咦!Spring容器里为什么没有我需要的Bean?
【10月更文挑战第11天】项目经理给小菜分配了一个紧急需求,小菜迅速搭建了一个SpringBoot项目并完成了开发。然而,启动测试时发现接口404,原因是控制器包不在默认扫描路径下。通过配置`@ComponentScan`的`basePackages`字段,解决了问题。总结:`@SpringBootApplication`默认只扫描当前包下的组件,需要扫描其他包时需配置`@ComponentScan`。
|
2月前
|
架构师 Java 开发者
得物面试:Springboot自动装配机制是什么?如何控制一个bean 是否加载,使用什么注解?
在40岁老架构师尼恩的读者交流群中,近期多位读者成功获得了知名互联网企业的面试机会,如得物、阿里、滴滴等。然而,面对“Spring Boot自动装配机制”等核心面试题,部分读者因准备不足而未能顺利通过。为此,尼恩团队将系统化梳理和总结这一主题,帮助大家全面提升技术水平,让面试官“爱到不能自已”。
得物面试:Springboot自动装配机制是什么?如何控制一个bean 是否加载,使用什么注解?
|
20天前
|
存储 安全 Java
springboot当中ConfigurationProperties注解作用跟数据库存入有啥区别
`@ConfigurationProperties`注解和数据库存储配置信息各有优劣,适用于不同的应用场景。`@ConfigurationProperties`提供了类型安全和模块化的配置管理方式,适合静态和简单配置。而数据库存储配置信息提供了动态更新和集中管理的能力,适合需要频繁变化和集中管理的配置需求。在实际项目中,可以根据具体需求选择合适的配置管理方式,或者结合使用这两种方式,实现灵活高效的配置管理。
13 0
下一篇
无影云桌面