非本人总结的笔记，抄点笔记复习复习。感谢传智博客及黑马程序猿

感谢传智博客及黑马程序猿

Spring概述

Spring是一个开源框架

Spring是于2003 年兴起的一个轻量级的Java开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许使用者选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。

Spring的核心有两个部分：IOC控制反转和Aop面向切面编程

IOC：控制反转

控制反转，之前调用一个类中的不是静态的方法，创建类的对象new类，再调用。现在使用Spring的IOC之后，不需要自己手动new创建对象，交给Spring进行管理。

Aop：面向切面编程

面向切面编程，在基本功能之上，可以添加一个额外功能，不添加额外功能，基本功能也可以运行。Aop底层原理动态代理

Spring是JavaEE的分层的一站式框架

针对JavaEE的三层结构分别有不同的方案。

JavaEE三层结构

Web层：springmvc

业务逻辑层：spring的ioc

持久化层：spring的jdbc模板

Spring的版本

Spring 3.x和4.x

Spring的好处

方便解耦，简化开发

Spring就是一个大工厂，可以将所有的对象创建和依赖关系维护，交给spring维护

AOP编程的支持

Spring提供面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等功能

声明式事务的支持

只需要通过配置就可以完成对事务的管理，而无需手动编程

方便程序的测试

Spring对Junit4支持，可以通过注解方便的测试Spring程序

方便集成各种优秀框架

Spring不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz等）的直接支持

降低JavaEE API的使用难度

Spring对JavaEE开发中非常难用的一些API（JDBC、JavaMail、远程调用等），都提供了封装，使这些API应用难度大大降低

Spring的IOC入门

Spring的开发包

Spring的开发包

导入Spring的jar包

Core Container

Sping

导入的核心四个jar包，需要到下面文件夹里面找

文件夹

beans

core

context

expression

需要日志的输出，导入第三方的日志jar包

framework

log4j

最终使用六个jar包

jar包

IOC底层原理

IOC： 把对象的创建交给Spring管理，不需要手动创建对象

画图分析IOC实现原理

IOC底层原理

IOC的入门

第一步：导入jar包

jar包

第二步：创建配置文件

在src下面创建配置文件，名称没有固定的要求，一般是applicationContext.xml

引入约束，之前在Struts2或者Hibernate里面引入约束是dtd约束，在spring里面的配置文件映入的是schema约束，可以在文件中找到该约束

路径

schema约束文件

第三步：创建类

创建类，在类里面创建方法

package cn.itcast.ioc;

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

public class TestIOCDemo1 {
    public void run1() {
        System.out.println("run1................");
    }   
    public static void main(String[] args) {
        //创建TestIOCDemo1对象
        TestIOCDemo1 demo1 = new TestIOCDemo1();
        demo1.run1();
    }
    //第五步 写测试方法测试对象是否创建
    @Test
    public void iocDemo1() {
        //加载配置文件，创建对象
        //applicationContext.xml配置文件的名称
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据bean里面的id值获取创建的对象
        //"demo1"是配置文件中id的值
        TestIOCDemo1 ioc1 = (TestIOCDemo1) context.getBean("demo1");
        System.out.println(ioc1);
        ioc1.run1();
    }
}

第四步：对象创建

在配置文件中配置哪个类进行对象创建

第五步：测试

写测试方法测试对象是否创建

IOC(控制反转)和DI(依赖注入)区别

IOC(控制反转):把对象的创建权交个spring管理

DI(依赖注入)：在对象创建过程中，可以向对象所在的类里面的属性中设置值，这个过程称为依赖注入

依赖注入需要在控制反转的基础上完成

代码演示

第一步

首先在类创建一个属性，必须生成set方法

package cn.itcast.ioc;

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

public class TestIOCDemo1 {

    private String username;
    public void setUsername(String username) {
        this.username = username;
    }

    public void run1() {
        System.out.println("run1................"+username);
    }
    
    public static void main(String[] args) {
        //创建TestIOCDemo1对象
        TestIOCDemo1 demo1 = new TestIOCDemo1();
        demo1.run1();
    }
    
    @Test
    public void iocDemo1() {
        //加载配置文件，创建对象
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        //根据bean里面的id值获取创建的对象
        TestIOCDemo1 ioc1 = (TestIOCDemo1) context.getBean("demo1");
        System.out.println(ioc1);
        ioc1.run1();
    }
}

第二步

在配置创建对象的bean标签里面配置属性的注入

Spring的工厂类

ApplicationContext

     |----ClassPathXmlApplicationContext :解析类路径下的XML的.

     |----FileSystemXmlApplicationContext    :解析本地磁盘上的XML的.

UML图

BeanFactory和ApplicationContext都是Spring的工厂

BeanFactory是Spring工厂的老版本类：第一次调用getBean方法的时候实例化

ApplicationContext是Spring新版本的工厂类：在加载核心配置文件的时候，将所有的类实例化

Spring的bean管理(xml配置--非注解)

bean管理：创建对象的过程，创建对象的过程中设置属性值

Bean的实例化的三种方式(Spring创建对象的三种方式)

第一种：使用无参的构造方法创建

第一步：创建类

package cn.itcast.beanxml;

/**
 * 使用无参数的构造方法创建
 */
public class Bean1 {
    public Bean1() {
    }
    public void b1() {
        System.out.println("bean1................");
    }
}

第二步：在配置文件application.xml中配置

第三步：创建测试类

package cn.itcast.beanxml;

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

public class TestBean {
    
    @Test
    public void beanioc1() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean1 = (Bean1) context.getBean("bean1");
        System.out.println(bean1);
        bean1.b1();
    }
}

第二种：使用静态工厂创建

静态工厂：这个工厂类的里面的方法是static的，可以通过类名直接调用

实态工厂：这个工厂类的里面的方法不是static的，创建工厂的对象，再调用里面的方法

第一步：创建类

package cn.itcast.beanxml;
/**
 * 使用静态工厂创建对象
 */
public class Bean2 {

    public void b2() {
        System.out.println("b2...............");
    }
}

第二步：创建静态工厂类

package cn.itcast.beanxml;
/**
 * 使用静态工厂创建对象
 */
public class Bean2Factory {

    //静态方法
    public static Bean2 getBean2() {
        return new Bean2();
    }
}

第三步：在配置文件application.xml中配置

第四步：创建测试类

package cn.itcast.beanxml;

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

public class TestBean {
    
    @Test
    public void beanioc2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean2 bean2 = (Bean2) context.getBean("bean2");
        System.out.println(bean2);
        bean2.b2();
    }
}

第三种：使用实例工厂创建

第一步：创建类

package cn.itcast.beanxml;
/**
 * 使用实例工厂创建对象
 */
public class Bean3 {

    public void b3() {
        System.out.println("b3................");
    }
}

第二步：创建静态工厂类

package cn.itcast.beanxml;

/**
 * 实例工厂创建
 */
public class Bean3Factory {

    public Bean3 getBean3() {
        return new Bean3();
    }
}

第三步：在配置文件application.xml中配置

第四步：创建测试类

package cn.itcast.beanxml;

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

public class TestBean {
    
    @Test
    public void beanioc3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean3 bean3 = (Bean3) context.getBean("bean3");
        System.out.println(bean3);
        bean3.b3();
    }
}

Spring的bean的常用配置

标签的id和name属性

id和name有什么区别？

id：使用xml中id约束，不可以出现特殊字符

name：出现特殊字符，如果使用了name没有id，那么name可以作为id使用

Spring整合Struts1:

上生命周期的配置

@Test
/**
* Bean的生命周期的相关配置:
*   * init-method
*   * destory-method :只能针对单例对象有效.必须在工厂关闭之后才会销毁对象.
*/
public void demo1(){
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
    EmployeeService employeeService = (EmployeeService) applicationContex.getBean("employeeService");
    employeeService.save();
    applicationContext.close();
}

上的作用范围的配置

scope属性:

singleton :单例的.(默认)
prototype :多例的.
request :WEB项目中,创建一个对象,保存到request域中.
session :WEB项目中,创建一个对象,保存到session域中.

*globalsession :WEB项目中,特殊环境.分布式开发环境.如果没有分布式环境,相当于session.

Bean的生命周期

Spring的实例化bean过程中总共完成11步骤

instantiate bean对象实例化
populate properties 封装属性
如果Bean实现BeanNameAware执行setBeanName
如果Bean实现BeanFactoryAware或者ApplicationContextAware设置工厂setBeanFactory或者上下文对象setApplicationContext
如果Bean存在类实现BeanPostProcessor(后处理Bean)，执行postProcessBeforeInitialization
如果Bean实现InitializingBean执行afterPropertiesSet
调用指定初始化方法init
如果存在类实现 BeanPostProcessor（处理Bean），执行postProcessAfterInitialization
执行业务处理
如果Bean实现 DisposableBean 执行 destroy
调用指定销毁方法 customerDestroy

第三步和第四步:主要让生成Bean了解Spring容器.

第五步和第八步:允许客户在Bean的生成过程中对Bean的实例进行增强.

BeanPostProcessor:工厂勾子.允许客户在生成类的过程中对类进行增强.

java里三种方式注入Bean属性

第一种：使用set方法注入

public class User() {
    private String username;
    public void setUsername(String username) {
        this.username = username; 
    }  
}

User user = new User();
user.setUsername("东方不败");

第二种：使用有参数的构造方法注入

public class Person{
    private int age;
    public Person(int age) {
        this.age = age;      
    }
}

Person p = new Person("岳不群");

第三种：使用接口注入

public interface Dao{
    public void run(String password);
}

public class UserDaoImpl implements Dao {
    private String password;
    public void run(String password) {
        this.passwordd = password;
    }
}

在Spring里面只是支持里面两种

第一种：使用set方法注入

第二种：使用有参数的构造注入

❤Spring注入bean属性的两种方式

Spring使用有参构造方法注入

第一步：创建类

创建类，声明属性，创建类有参数的构造方法

package cn.itcast.field;
/**
 * 使用有参数的构造方法注入属性
 */
public class ConstructorField {

    //声明属性
    private String username;
    private String password;
    //创建有参数构造方法
    public ConstructorField(String username, String password) {
        this.username = username;
        this.password = password;
    }
    
    public void demo1() {
        System.out.println("field1......"+username+" :: "+password);
    }
    
}

第二步：在配置文件里面配置

在配置文件里面进行配置，可以参数名称或者参数的位置配置值，applicationContext.xml

第三步：创建测试类

package cn.itcast.field;

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

public class TestField {

@Test
    public void field1() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        ConstructorField field1 = (ConstructorField) context.getBean("field1");
        field1.demo1();
    }
}

Spring使用set方法注入

第一步：创建类

package cn.itcast.field;
/**
 * 使用属性的set方法注入
 */
public class SetField {

    //声明属性
    private String sname;
    private String address;
    //生成对应的set方法
    public void setSname(String sname) {
        this.sname = sname;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    
    public void set1() {
        System.out.println("set.."+sname+" :: "+address);
    }
    
    public static void main(String[] args) {
        SetField set1 = new SetField();
        set1.setSname("aaa");
        set1.setAddress("bbb");
    }
}

第二步：在配置文件里面配置

在配置文件里面配置application.xml

第三步：创建测试类

package cn.itcast.field;

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

public class TestField {

    @Test
    public void field2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SetField setField = (SetField) context.getBean("field2");
        System.out.println(setField);
        setField.set1();
    }
}

Spring复杂注入，使用引入其他bean

第一步：创建两个类

package cn.itcast.field;

public class Car {
    /**
     * 创建car对象，注入两个属性值
     */
    private String cname;
    private String color;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setColor(String color) {
        this.color = color;
    }
    
    public void testcar() {
        System.out.println("car: "+cname+" :: "+color);
    }
}

package cn.itcast.field;

public class Person {

    //把car对象注入进来
    //把car作为当前person的一个属性
    private Car car;
    public void setCar(Car car) {
        this.car = car;
    }

    public void test1() {
        car.testcar();
    }
    
    /**
     * 传统方式
     */
    public void testperson() {
        Car car = new Car();
        car.setCname("aaa");
        car.setColor("red");
        car.testcar();
    }
    
    public static void main(String[] args) {
        Person p = new Person();
        p.testperson();
    }
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.field;

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

public class TestField {

    @Test
    public void field3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        Person p = (Person) context.getBean("person");
        p.test1();
    }
}

Spring3.0的SpEL的属性注入(SpEL:Spring Expression Language)

SpEL语法：

语法：#{SpEL}

SpEL用法：

Spring的2.5支持p名称空间注入属性(会用)

为了简化XML文件配置，Spring从2.5开始引入一个新的p名称空间

第一步：创建类

创建类，声明属性，生成set方法

package cn.itcast.field;

public class Car {
    /**
     * 创建car对象，注入两个属性值
     */
    private String cname;
    private String color;
    public void setCname(String cname) {
        this.cname = cname;
    }
    public void setColor(String color) {
        this.color = color;
    }
    
    public void testcar() {
        System.out.println("car: "+cname+" :: "+color);
    }
}

第二步：在配置文件里面进行配置

声明空间和配置



       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

第三步：创建测试类

package cn.itcast.field;

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

public class TestField {

    @Test
    public void field4() {
        ApplicationContext context = 
                new ClassPathXmlApplicationContext("applicationContext.xml");
        Car car = (Car) context.getBean("car");
        car.testcar();
    }
}

数组集合属性注入

数组属性注入

在一个类中，有一个属性，属性类型是数组形式，向数组的属性里面设置值

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Arrays;

/**
 * 数组属性的注入
 */
public class ArrayField {

    //声明数组属性
    private String[] arr;
    //set方法
    public void setArr(String[] arr) {
        this.arr = arr;
    }
    
    public void testarray() {
        System.out.println(Arrays.toString(arr));
    }
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.arraycollection;

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

public class TestArrayCollection {
    
    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ArrayField array = (ArrayField) context.getBean("arrayField");
        array.testarray();
    }
}

list集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.List;

/**
 * list集合属性的注入
 */
public class ListField {

    private List list;
    public void setList(List list) {
        this.list = list;
    }
    
    public void testlist() {
        for(String value:list) {
            System.out.println("********* "+value);     
        }
    }   
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.arraycollection;

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

public class TestArrayCollection {
    
    @Test
    public void demo2() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        ListField list = (ListField) context.getBean("listField");
        list.testlist();
    }
}

Set集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Set;

/**
 * set集合属性的注入
 */
public class SetField {

    private Set set;
    public void setSet(Set set) {
        this.set = set;
    }
    
    public void testset() {
        for(String value : set) {
            System.out.println("===== "+value);
        }
    }
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.arraycollection;

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

public class TestArrayCollection {
    
    @Test
    public void demo3() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        SetField set = (SetField) context.getBean("setField");
        set.testset();
    }
}

Map集合属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Map;

/**
 * map集合属性的注入
 */
public class MapField {

    private Map map;
    public void setMap(Map map) {
        this.map = map;
    }

    public void testmap() {
        System.out.println(map);
    }
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.arraycollection;

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

public class TestArrayCollection {
    
    @Test
    public void demo4() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        MapField mapField = (MapField) context.getBean("mapField");
        mapField.testmap();
    }
}

Properties属性注入

第一步：创建类

package cn.itcast.arraycollection;

import java.util.Properties;

/**
 * Properties类型属性的注入
 */
public class PropertiesField {

    private Properties properties;
    public void setProperties(Properties properties) {
        this.properties = properties;
    }
    public void testproperties() {
        System.out.println(properties);
    }
}

第二步：在配置文件里面配置

第三步：创建测试类

package cn.itcast.arraycollection;

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

public class TestArrayCollection {
    
    @Test
    public void demo5() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        PropertiesField propertiesField = (PropertiesField) context.getBean("propertiesField");
        propertiesField.testproperties();
    }
}

Spring的bean管理(注解配置)

回顾：注解，代码里面特殊标记，写法@注解名称(值)，注解使用在类上面，方法上面，属性上面

入门案例

第一步：在配置文件里面进行配置

第二步：创建类

package cn.itcast.annotation;

import org.springframework.stereotype.Controller;
//类似于之前xml配置文件
  
@Controller(value="hello")
public class Hello {

    public void say() {
        System.out.println("hello annotation........");
    }
}

第三步：创建测试类

package cn.itcast.annotation;

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

public class TestAnno {
    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext1.xml");
        Hello hello = (Hello) context.getBean("hello");
        System.out.println(hello);
        hello.say();
    }
}

Bean管理常用的注解

第一部分注解：用来生成类对象

注解	功能
@Component	生成类对象
@Repository	用于对Dao实现类进行标注
@Service	用于对Service实现类进行标注
@Controller	用于对Controller实现类进行标注

这四个注解的功能是一样的，都是用来生成类的对象，可以使用在类上面

@Controller(value="hello")
public class Hello{
  
}

第二部分注解：做注入的操作，把类对象注入到另一个类中

在此类中声明要注入的对象所在类，作为一个属性，不需要set方法

使用@Autowried进行自动注入(自动装配)，根据类对象名称，找到类的对象

@Autowried
private UserDao userDao;

使用@Resource(name="值")实现指定哪个对象注入

@Component(value="userDao")
public class UserDao{
  
}

@Resource(name="userDao")
private UserDao userDao;

Resource里面的name值和@Component里面的value值一样

综合练习

创建Service类，调用两个Dao里面的方法，在Service里面得到两个dao的对象

第一步：创建类

package cn.itcast.lianxi;

import javax.annotation.Resource;

public class PersonService {
    //属性的注入使用注解方式完成
    @Resource(name="productDao")
    private ProductDao productDao;
    
    @Resource(name="ordersDao")
    private OrdersDao ordersDao;
    
    public void testservice() {
        System.out.println("service执行了.......");
        productDao.testproduct();
        ordersDao.testorder();
    }
}

package cn.itcast.lianxi;

public class ProductDao {

    public void testproduct() {
        System.out.println("productdao执行了...........");
    }
}

package cn.itcast.lianxi;

public class OrdersDao {

    public void testorder() {
        System.out.println("orderdao执行了...............");
    }
}

第二步：在配置文件里面进行配置

第三步：创建测试类

package cn.itcast.lianxi;

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

public class TestAnno {

    @Test
    public void demo1() {
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext1.xml");
        PersonService servcie = (PersonService) context.getBean("personService");
        servcie.testservice();
    }
}

Spring--day01

Spring概述

Spring是一个开源框架

Spring的核心有两个部分：IOC控制反转和Aop面向切面编程

IOC：控制反转

Aop：面向切面编程

Spring是JavaEE的分层的一站式框架

Spring的版本

Spring的好处

方便解耦，简化开发

AOP编程的支持

声明式事务的支持

方便程序的测试

方便集成各种优秀框架

降低JavaEE API的使用难度

Spring的IOC入门

Spring的开发包

导入Spring的jar包

导入的核心四个jar包，需要到下面文件夹里面找

需要日志的输出，导入第三方的日志jar包

最终使用六个jar包

IOC底层原理

IOC的入门

第一步：导入jar包

第二步：创建配置文件

第三步：创建类

第四步：对象创建

第五步：测试

IOC(控制反转)和DI(依赖注入)区别

代码演示

第一步

第二步

Spring的工厂类

Spring的bean管理(xml配置--非注解)

Bean的实例化的三种方式(Spring创建对象的三种方式)

第一种：使用无参的构造方法创建

第一步：创建类

第二步：在配置文件application.xml中配置

第三步：创建测试类

第二种：使用静态工厂创建

第一步：创建类

第二步：创建静态工厂类

第三步：在配置文件application.xml中配置

第四步：创建测试类

第三种：使用实例工厂创建

第一步：创建类

第二步：创建静态工厂类

第三步：在配置文件application.xml中配置

第四步：创建测试类

Spring的bean的常用配置

标签的id和name属性

上生命周期的配置

上的作用范围的配置

Bean的生命周期

java里三种方式注入Bean属性

第一种：使用set方法注入

第二种：使用有参数的构造方法注入

第三种：使用接口注入

❤Spring注入bean属性的两种方式

Spring使用有参构造方法注入

第一步：创建类

第二步：在配置文件里面配置

第三步：创建测试类

Spring使用set方法注入

第一步：创建类

第二步：在配置文件里面配置

第三步：创建测试类

Spring复杂注入，使用引入其他bean

第一步：创建两个类

第二步：在配置文件里面配置

第三步：创建测试类

Spring3.0的SpEL的属性注入(SpEL:Spring Expression Language)

SpEL语法：

SpEL用法：

Spring的2.5支持p名称空间注入属性(会用)

第一步：创建类

第二步：在配置文件里面进行配置

第三步：创建测试类

数组集合属性注入

数组属性注入