Spring

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

Spring : 春天 —> 给软件行业带来了春天

2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。

2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

很难想象Rod Johnson的学历 , 他是悉尼大学的博士，然而他的专业不是计算机，而是音乐学。

理念

使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网&文档&下载

官网 : http://spring.io/

官方下载地址 : https://repo.spring.io/libs-release-local/org/springframework/spring/

GitHub : https://github.com/spring-projects

Spring 官方文档

Spring 中文文档

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>
</dependencies>

优点

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

• Spring是一个开源的免费的框架（容器）！！！
• Spring是一个轻量级的、非侵入式的框架！！！
• 控制反转 IoC , 面向切面 Aop（面试经常问到）
• 支持对事务的处理
• 支持对框架的整合

Spring框架是一种非侵入式的轻量级框架——摘自《Spring框架技术》

1. 非侵入式的技术体现

• 允许在应用系统中自由选择和组装Spring框架的各个功能模块，并且不强制要求应用系统的类必须从Spring框架的系统API的某个类来继承或者实现某个接口。

2. 如何实现非侵入式的设计目标的

• 1）应用反射机制，通过动态调用的方式来提供各方面的功能，建立核心组间BeanFactory
• 2）配合使用Spring框架中的BeanWrapper和BeanFactory组件类最终达到对象的实例创建和属性注入
• 3）优点：允许所开发出来的应用系统能够在不用的环境中自由移植，不需要修改应用系统中的核心功能实现的代码

组成

拓展

• 现代化的Java开发（即，基于Spring的开发）！！！

• Spring Boot

• Spring Cloud

现在大多数公司都在使用SpringBoot进行快速开发。

承上启下：学习SpringBoot的前提，是完全掌握Spring以及SpringMVC！！！

Spring Boot

• Spring Boot 是 Spring 的一套快速配置脚手架
• 可以基于Spring Boot 快速开发单个微服务
• Spring Boot专注于快速、方便集成的单个微服务个体
• Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置

弊端

• 发展太久了，违背了原来的理念！！！
• 配置十分繁琐，人称“配置地狱”！！！

Spring Cloud

• Spring Cloud是基于Spring Boot实现的
• Spring Cloud关注全局的服务治理框架
• Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系
• SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot

IoC 理论推导

1. UserDao 接口
2. UserDaoImpl 实现类
3. UserService 业务接口
4. UserServiceImpl 业务实现类

原来的实现

1、先写一个UserDao接口

public interface UserDao {
   public void getUser();
}

2、再去写Dao的实现类

public class UserDaoImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("获取用户数据");
  }
}

3、然后去写UserService的接口

public interface UserService {
   public void getUser();
}

4、最后写Service的实现类

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoImpl();

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

5、测试一下

@Test
public void test(){
   UserService service = new UserServiceImpl();
   service.getUser();
}

修改

这是我们原来的方式 , 开始大家也都是这么去写的对吧 . 那我们现在修改一下 .

把Userdao的实现类增加一个 .

public class UserDaoMySqlImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("MySql获取用户数据");
  }
}

紧接着我们要去使用MySql的话 , 我们就需要去service实现类里面修改对应的实现

public class UserServiceImpl implements UserService {
   private UserDao userDao = new UserDaoMySqlImpl();

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

在假设, 我们再增加一个Userdao的实现类 .

public class UserDaoOracleImpl implements UserDao {
   @Override
   public void getUser() {
       System.out.println("Oracle获取用户数据");
  }
}

那么我们要使用Oracle , 又需要去service实现类里面修改对应的实现 . 假设我们的这种需求非常大 , 这种方式就根本不适用了, 甚至反人类吧 .

用户的需求可能会影响我们原来的代码

我们需要根据用户的需求去修改原代码！

如果程序代码量十分大，修改一次的成本代价十分昂贵！

根据每次变动 , 都需要修改大量代码 !

这种设计的耦合性太高了, 牵一发而动全身 !

改进优化

我们可以在需要用到他的地方 , 不去实现它 , 而是留出一个接口 , 利用一个set接口 , 我们去代码里修改下 :

public class UserServiceImpl implements UserService {
   private UserDao userDao;
   //利用set实现值的动态注入
   public void setUserDao(UserDao userDao) {
       this.userDao = userDao;
  }

   @Override
   public void getUser() {
       userDao.getUser();
  }
}

现在去我们的测试类里 , 进行测试 ;

@Test
public void test(){
   UserServiceImpl service = new UserServiceImpl();
   service.setUserDao( new UserDaoMySqlImpl() );
   service.getUser();
    
   //那我们现在又想用Oracle去实现呢
   service.setUserDao( new UserDaoOracleImpl() );
   service.getUser();
}

发现了区别没有？

他们已经发生了根本性的变化 , 很多地方都不一样了。

• 之前，所有东西都是由程序去进行控制创建，控制权在程序员手上！
• 现在，使用set注入后，是由我们自行控制创建对象 , 把主动权交给了调用者。程序不再有主动性，而是变成了被动的接收对象。
• 程序不用去管怎么创建，怎么实现了。它只负责提供一个接口。

这种思想 , 从本质上解决了问题 , 我们程序员不再去管理对象的创建了 , 更多的去关注业务的实现 . 耦合性大大降低 . 这也就是IOC的原型 !

IoC本质

• 控制反转IoC(Inversion of Control)

• 控制反转是一种通过描述（XML或注解）并通过第三方去生产或获取特定对象的方式。在Spring中实现控制反转的是IoC容器，其实现方法是依赖注入（Dependency Injection,DI）。
• 是一种设计思想，DI(依赖注入)是实现IoC的一种方法，也有人认为DI只是IoC的另一种说法。

没有IoC的程序中 , 我们使用面向对象编程 , 对象的创建与对象间的依赖关系完全硬编码在程序中，对象的创建由程序自己控制，控制反转后将对象的创建转移给第三方，个人认为所谓控制反转就是：获得依赖对象的方式反转了。

Spring和IoC的关系

• IoC是Spring框架的核心内容，使用多种方式完美的实现了IoC：
  • ①可以使用XML配置
  • ②也可以使用注解
  • ③新版本的Spring也可以零配置实现IoC（即自动装配）。

Spring容器在初始化时先读取配置文件，

根据配置文件或元数据创建与组织对象存入容器中，

程序使用时再从Ioc容器中取出需要的对象。

• 采用XML方式配置Bean的时候，Bean的定义信息是和实现分离的
• 而采用注解的方式可以把两者合为一体，Bean的定义信息直接以注解的形式定义在实现类中，从而达到了零配置的目的。

HelloSpring入门程序

①基础环境

• JDK ：12
• Spring：5.2.7
• Junit：4.12
• IDEA：2020.1.2

②导入jar包

注 : spring 需要导入commons-logging进行日志记录 . 我们利用maven , 他会自动下载对应的依赖项

<dependencies>
    <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.2.7.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

③编写代码

1、编写一个Hello实体类

package com.melodyhub.pojo;

public class Hello {
    private String name;

    public String getName() {
        return name;
    }

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

    @Override
    public String toString() {
        return "Hello{" +
                "name='" + name + '\'' +
                '}';
    }
}

2、编写我们的spring文件 , 这里我们命名为beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--使用Spring来创建对象，在Spring中这些都成为bean
    类型 变量名 = new 类型();
    Hello hello = new Hello();

    id = 变量名
    class = new 的对象
    property 相当于给对象中的属性赋值
        
     注意: 这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写。
     引用另外一个bean , 不是用value, 而是用 ref 。

    <bean id="..." class="...">
        &lt;!&ndash; collaborators and configuration for this bean go here &ndash;&gt;
    </bean>-->

    <!--bean就是java对象, 在Spring中都成为Bean，由Spring创建和管理-->
    <bean id="hello" class="com.melodyhub.pojo.Hello">
        <property name="str" value="Spring"/>
    </bean>

    <!--注意: 
       这里的name并不是属性 , 而是set方法后面的那部分 , 首字母小写。
       ref:引用Spring容器中创建好的对象。引用另外一个bean , 不是用value, 而是用ref。
        value：具体的值，基本数据类型！
     -->
        
    <!-- more bean definitions go here -->

</beans>

3、我们可以去进行测试了

import com.melodyhub.pojo.Hello;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MyTest {
    public static void main(String[] args) {
        //获取Spring的上下文对象
        //解析beans.xml文件,生成管理相应的Bean对象
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        //我们的对象现在在Spring中创建和管理了
        //要使用对象，直接去Spring中取出来就可以了
        //getBean:参数即为spring配置文件中bean的id
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

入门踩坑

JDK8不兼容Spring4.x以下版本

入门三天，我一直被这控制台一片红苦恼着。

在视频的评论区中没有解决，上论坛上也没有解决。

详细报错：

org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
信息: Loading XML bean definitions from class path resource [beans.xml]
Exception in thread "main" java.lang.NoSuchMethodError: org.springframework.core.annotation.AnnotationUtils.clearCache()V
	at org.springframework.context.support.AbstractApplicationContext.resetCommonCaches(AbstractApplicationContext.java:924)
	at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:575)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:144)
	at org.springframework.context.support.ClassPathXmlApplicationContext.<init>(ClassPathXmlApplicationContext.java:85)
	at MyTest.main(MyTest.java:13)

解决

知道我无意间看到这个！！！

Ctrl+Shift+Alt+S，进入项目设置，更换项目的JDK版本为8以上，我选择的是JDK12：

如果以上设置还法子解决，那可能还需要再修改spring-study.iml文件：

不支持发行版本5 或 Compilation failed: internal java compiler error

提示

Error: java: 错误: 不支持发行版本 5

或

``Error: java: 错误: Compilation failed: internal java compiler error`

分析：

导致这个错误的原因主要是因为JDK版本问题，此处有两个原因，一个是编译版本不匹配，一个是当前项目JDK版本不支持。我的是编译器版本的问题。

解决：

Ctrl+Alt+S，进入IDEA设置，Compiler中设置Java编译器的版本。

解决来源：https://blog.csdn.net/wo541075754/article/details/82119860

思考

Hello对象是谁创建的？

Hello对象是由Spring创建的

Hello对象的属性是怎么设置的？

Hello对象的属性是由Spring容器设置的

这个过程就叫控制反转

• 控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

• 反转 : 程序本身不创建对象 , 而变成被动的接收对象

• 依赖注入(DI) : 就是利用set方法来进行注入的

IOC是一种编程思想，由主动的编程变成被动的接收

可以通过newClassPathXmlApplicationContext去浏览一下底层源码

OK , 到了现在 , 我们彻底不用再程序中去改动了 , 要实现不同的操作 , 只需要在xml配置文件中进行修改 , 所谓的IoC,一句话搞定 : 对象由Spring来创建 , 管理 , 装配 !

IoC创建对象的方式

一、默认：使用无参构造创建对象

Spring中默认：使用无参构造创建对象

传送门：依赖注入-构造器

二、使用有参构造创建对象

1. 通过 下标 赋值
2. 通过 类型 赋值
3. 直接通过 属性名 赋值

1.下标赋值

<!--第1种方式：下标赋值-->
<bean id="user" class="com.melodyhub.pojo.User">
    <!--<property name="name" value="MelodyJerry"/>-->
    <constructor-arg index="0" value="下标赋值：MeloduHub-MelodyJerry"/>
</bean>

2.类型赋值

<!--第2种方式：类型赋值-->
<bean id="user" class="com.melodyhub.pojo.User">
    <constructor-arg type="java.lang.String" value="类型赋值：MeloduHub-MelodyJerry"/>
</bean>

3.直接通过属性名赋值

<!--第3种方式：直接通过属性值实现赋值-->
<bean id="user" class="com.melodyhub.pojo.User">
    <constructor-arg name="nmae" value="直接通过属性值实现赋值：MeloduHub-MelodyJerry"/>
</bean>

总结：在Spring配置文件加载(即创建Bean)时，容器中管理的对象就已经被初始化/实例化了，而且内存中只有1份实例！

UserTwo.java中：

public class UserTwo {
    private String name;

    //必须要有无参构造子，没有就会报错！！！
    public UserTwo(){
        System.out.println("UserTwo被创建了！！！");
    }

    public String getName() {
        return name;
    }

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

    public void show(){
        System.out.println("name = " + name);
    }
}

beans.xml文件中：

<!--Spring创建Bean的时候就实例化对象-->
<bean id="userTwo" class="com.melodyhub.pojo.UserTwo"></bean>

MyTest.java中：

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("user");
        User user2 = (User) context.getBean("user");
        //user.show();
        System.out.println(user == user2);
    }
}

控制台输出：

UserTwo被创建了！！！
true

Spring的xml配置文件说明

alias：别名

• 如果增加了别名，我们也可以通过别名获取到这个对象！

Demo

为user增加别名：woshibieming

<bean id="user" class="com.melodyhub.pojo.User">
    <constructor-arg name="nmae" value="直接通过属性值实现赋值：MeloduHub-MelodyJerry"/>
</bean>

<!--alias:别名.如果增加了别名,我们也可以通过别名获取到这个对象-->
<alias name="user" alias="woshibieming"/>

修改getBean中的参数：woshibieming

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean("woshibieming");
        user.show();
    }
}

bean标签的配置

• id：bean的唯一标识符，也就是相当于我们学的对象名
• class：bean对象所对应的全限定名：包名+类名
• name：也是别名，而且name可以同时取多个别名
  • 分隔符：逗号、空格、分号
• autowire：自动导入
• scope：作用域。默认singleton(单例模式)，可选prototype(原型模式)、request、session、globalsession。更多详见：spring常用注解-@Scope、Spring Bean的scope(作用域)

Demo

测试bean标签的配置，并同时设置多个别名：two、u2、u3、u4

<bean id="userTwo" class="com.melodyhub.pojo.UserTwo" name="two u2,u3;u4">
    <property name="name" value="测试bean标签的配置，并同时设置多个别名：two、u2、u3、u4"/>
</bean>

修改getBean中的参数：u3

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserTwo user = (UserTwo) context.getBean("u3");
        user.show();
    }
}

控制台输出：

UserTwo被创建了！！！
name = 测试bean标签的配置，并同时设置多个别名：two、u2、u3、u4

import

• 一般用于团队开发使用，import可以将多个配置文件，导入合并为一个。
• 而且，相同 id的对象的属性也会被合并到一起！！！

Demo

假设现在项目中有多个人开发，张三（beans.xml）、李四（beans2.xml）、王五（beans3.xml），这三个人负责不同的类开发，不同的类需要注册在不同的bean中，我们可以利用import将所有人的beans.xml合并为一个总的applicationContext.xml！

• 张三（beans.xml）

• 李四（beans2.xml）

• 王五（beans3.xml）

• applicationContext.xml

新建applicationContext.xml文件，在IDEA的编辑区的右上角会看到蓝色的Configure application contex，单击并合并到原先的beans.xml中去

但是现在要合并到applicationContext.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <import resource="beans.xml"/>
    <import resource="beans2.xml"/>
    <import resource="beans3.xml"/>

</beans>

当然 也可以在ClassPathXmlApplicationContext中直接获取多个配置文件👇

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml","beans2.xml","beans3.xml");
//ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

现在来看看对象的属性的合并，修改Bean2.xml、bean3.xml中user的别名

MyTest中修改getBean的参数为：u8

public class MyTest {
    public static void main(String[] args) {
//        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml","beans2.xml","beans3.xml");
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserTwo user = (UserTwo) context.getBean("u8");
        user.show();
    }
}

控制台输出：

UserTwo被创建了！！！
name = 测试bean标签的配置，并同时设置多个别名：two、u2、u3、u8

总结

• import可以将多个配置文件，导入合并为一个。

• 而且，相同 id的对象的属性也会被合并到一起！！！

依赖注入（DI）

• 依赖注入：Dependency Injection，简称DI
• 依赖注入(DI)是控制反转(IoC)的一种方式。
• 官方文档：https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#beans-dependencies
• 拥有三种依赖注入的方式
  • 构造器（构造方法）注入
  • Setter方式注入【重点】
  • 接口注入

更多详见：三种依赖注入的方式

构造器注入

传送门：IoC创建对象的方式

Setter方式注入【重点】

• 依赖注入：Set注入！
  • 依赖：bean对象的创建依赖于容器！
  • 注入：bean对象中的所有属性，由容器来注入！

DEMO

1. 复杂类型

public class Address {
    private String address;

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }

    @Override
    public String toString() {
        return "Address{" +
                "address='" + address + '\'' +
                '}';
    }
}

2. 真是测试对象

package com.melodyhub.pojo;

import java.util.*;

public class Student {
    private String name;
    private Address address;
    private String[] books;
    private List<String> hobbys;
    private Map<String, String > card;
    private Set<String> games;
    private String wife;
    private Properties info;

    public String getName() {
        return name;
    }

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

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public String[] getBooks() {
        return books;
    }

    public void setBooks(String[] books) {
        this.books = books;
    }

    public List<String> getHobbys() {
        return hobbys;
    }

    public void setHobbys(List<String> hobbys) {
        this.hobbys = hobbys;
    }

    public Map<String, String> getCard() {
        return card;
    }

    public void setCard(Map<String, String> card) {
        this.card = card;
    }

    public Set<String> getGames() {
        return games;
    }

    public void setGames(Set<String> games) {
        this.games = games;
    }

    public String getWife() {
        return wife;
    }

    public void setWife(String wife) {
        this.wife = wife;
    }

    public Properties getInfo() {
        return info;
    }

    public void setInfo(Properties info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", address=" + address.toString() +
                ", books=" + Arrays.toString(books) +
                ", hobbys=" + hobbys +
                ", card=" + card +
                ", games=" + games +
                ", wife='" + wife + '\'' +
                ", info=" + info +
                '}';
    }
}

3. beans.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean name="student" class="com.melodyhub.pojo.Student">
        <!--第一种：普通值注入，value-->
        <property name="name" value="MelodyJerry"/>
    </bean>
    
</beans>

4. 测试类

public class MyTest {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        Student student = (Student) context.getBean("student");
        System.out.println(student.toString());
    }
}

5. 完善注入信息

<bean id="address" class="com.melodyhub.pojo.Address"/>
<bean name="student" class="com.melodyhub.pojo.Student">
    <!--第一种：普通值注入，value-->
    <property name="name" value="MelodyJerry"/>
    <!--第二种：Bean注入，ref-->
    <property name="address" ref="address"/>
    <!--数组注入-->
    <property name="books">
        <array>
            <value>西游记</value>
            <value>三国演义</value>
            <value>红楼梦</value>
            <value>水浒传</value>
        </array>
    </property>
    <!--List注入-->
    <property name="hobbys">
        <list>
            <value>听歌</value>
            <value>打球</value>
            <value>跑步</value>
            <value>学习</value>
        </list>
    </property>
    <!--Map注入-->
    <property name="card">
        <map>
            <entry key="身份证" value="1234567890"/>
            <entry key="银行卡" value="2364101"/>
        </map>
    </property>
    <!--Set注入-->
    <property name="games">
        <set>
            <value>王者荣耀</value>
            <value>LOL</value>
        </set>
    </property>
    <!--NULL注入-->
    <property name="wife">
        <null/>
    </property>
    <!--Property注入-->
    <!--
        <prop key="键">值</prop>
    -->
    <property name="info">
        <props>
            <prop key="性别">男</prop>
            <prop key="年龄">21</prop>
            <prop key="身高">186cm</prop>
        </props>
    </property>
</bean>

扩展方式注入

官方文档:

p-命名空间注入

• p：property

  The p-namespace lets you use the beanelement’s attributes (instead of nested <property/> elements) to describe your property values collaborating beans, or both.

• 必须导入：

xmlns:p="http://www.springframework.org/schema/p"

c-命名空间注入

• c：constructor-arg
• 类中必须存在 有参构造器

Similar to the XML Shortcut with the p-namespace, the c-namespace, introduced in Spring 3.1, allows inlined attributes for configuring the constructor arguments rather then nested constructor-arg elements.

• 必须导入：

xmlns:c="http://www.springframework.org/schema/c"

Demo

1. User.java

package com.melodyhub.pojo;

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public User() {

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

2. userbeans.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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <!--p命名空间注入，可以直接注入属性的值。property-->
    <bean id="user" class="com.melodyhub.pojo.User" p:age="21" p:name="MelodyJerry"/>

    <!--c命名空间注入，可以通过构造器注入属性的值。constructor-arg-->
    <bean id="user2" class="com.melodyhub.pojo.User" c:age="18" c:name="Jerry"/>

</beans>

3. MyTest.java

@Test
    public void test2(){
        ApplicationContext context = new ClassPathXmlApplicationContext("userbeans.xml");
        User user = context.getBean("user",User.class);
        User user2 = context.getBean("user2",User.class);
        System.out.println(user);
        System.out.println(user2);
    }

重点注意

• 使用前，必须导入对应的xml约束：xmlns:p或xmlns:c

• 使用c-命名空间的前提：类中必须存在有参构造器

• 同时使用p命名空间、c命名空间：类中必须存在 无参构造器、有参构造器

Bean作用域

官方文档：Bean Scopes

<bean id="beanname" class="com.linjie.Bean" scope="prototype"/>

• singleton（重点）
• prototype（重点）
• request
• session
• application
• websocket

Scope	描述
singleton 单例模式	(Spring默认使用singleton) 每一个Spring容器中，一个Bean定义只有一个对象实例
prototype 原型模式	允许Bean的定义可以被实例化任意次 （每次调用都创建一个实例）
request	一次HTTP请求中，每个Bean定义对应一个实例，该作用域仅在基于Web的Spring上下文（例如SpringMVC）中才有效
session	在一个HTTP Session中，每个Bean定义对应一个实例。该作用域仅在基于Web的Spring上下文（例如SpringMVC）中才有效
application	Scopes a single bean definition to the lifecycle of a ServletContext.该作用域仅在基于Web的Spring上下文（例如SpringMVC）中才有效
websocket	Scopes a single bean definition to the lifecycle of a WebSocket. 该作用域仅在基于Web的Spring上下文（例如SpringMVC）中才有效

更多参考：

Spring Bean的scope(作用域)

spring常用注解-@Scope

singleton 单例模式

• Spring模式机制
• 并发开发中可能存在问题
• 一般在单线程中会使用

<!-- the following is equivalent, though redundant (singleton scope is the default) -->
<bean id="accountService" class="com.something.DefaultAccountService" scope="singleton"/>

prototype 原型模式

• 每次从容器中get的时候，都产生一个新对象！
• 特别浪费资源
• 一般在多线程中会使用

<bean id="accountService" class="com.something.DefaultAccountService" scope="prototype"/>

注意

• 其余的request、session、application这些只能在web开发中使用！
• 一般，单线程使用singleton，多线程使用prototype

Spring其他一些细节

bean标签的使用

①

改进Spring的程序，加上beans.xml配置：

②

Spring创建Bean的时候就实例化对象

ApplicationContext.getBean()

• getBean(String name)
• getBean(Class<T> type)
• getBean(String name,Class<T> type)
• getBean(String name,Object[] args)

更多详见：ApplicationContext之getBean方法详解

直接获取所要的、某类型的对象

• 调用 getBean(String name,Class<T> type)

context.getBean("people", People.class);