Spring框架的基础使用
XML配置信息，Bean的不同实例化方式，注入
实例化
XML文件中的参数设置
1、通过构造器进行实例化（重点，常用方式）
<bean name="aClss2" class="com.stu.bean.AClass"></bean>
id：指定bean的名称，用于在spring中查找这个bean对象，除了id属性，也可以使用name属性来作为名称
注意：
（1）在同一个Spring容器中不能有id，name或id和name两两相同的bean定义
（2）id属性比name属性更严格，因此绝大多数时候使用id属性
class：指定bean的类型，用于从spring容器中查找这个bean对象
根据class对应的类型来从容器中获取对象
如果在bean定义中有多个定义对应的类型都能匹配，则发生异常
抽象类和接口不能被实例化 通过该方式实例化
2、通过静态工厂方法进行实例化
<bean id="cal" class="java.util.Calendar" factory-method="getInstance"></bean>
id:指定bean的名称
class:指定工厂类型
factory-method:用于指定工厂中创建bean对象的工厂方法，必须用static修饰
3、通过实例工厂方法进行实例化
<!-- 1.创建实例工厂 -->
<bean id="ggncal" class="java.util.GregorianCalendar"></bean>
<!-- 2.指定实例工厂并调用其中的实例工厂方法来获取对象 -->
<bean id="date" factory-bean="ggncal" factory-method="getTime"></bean>
4.JavaBean的作用域 scope属性
scope="prototype"：多例的
scope="singleton"：单例的（默认）
Bean的生命周期
- bean的定义 (xml文件、注解、java代码)
- bean的初始化
init-method=" " 当bean在被初始化的时候，会被调用的方法
(1)如果是singleton的bean，则在容器创建时就会初始化单例bean ,初始化方法只会被调用一次
(2)对于prototype的bean，则在要获取该bean的对象时进行初始化, 初始化方法在每次获取对象时都会被调用 - bean的调用
容器对象中的getBean()方法进行调用 - bean的销毁
销毁方法是在web环境下，停止服务时调用或通过销毁容器对象时调用
注意：对于singleton的bean，其生命周期完全有Spring容器控制，对于prototype则不完全是。
ps:
对于初始化方法和销毁方法吗，可以在beans节点中配置 default-init-method、default-destroy-method 来指定容器中每个bean的默认初始化方法，
如果在单独的bean中也配置了它自己的初始化方法和销毁方法，则以bean节点中单独配置的那个为准 - 延迟实例化
在ApplicationContext实现的默认行为就是在容器启动时将所有的singleton bean提前进行实例化
如果不想让一个singleton bean在ApplicationContext初始化时就提前实例化，可以使用bean元素的lazy-init属性进行改变
对于一个延迟实例化的bean，将在第一次调用时进行实例化
lazy-init="true" 延迟加载
A.通过构造器实例化和静态工厂实例化
先构建用来测试的两个实体类 AClass.java 和 BClass.java
AClass.Java
import java.io.Serializable; /** * 文件名称： com.stu.bean.AClass.java<br/> * 初始作者： Administrator<br/> * 创建日期： 2018-2-1<br/> * 功能说明： 例子用到的第一个类 <br/> * =================================================<br/> * 修改记录：<br/> * 修改作者 日期 修改内容<br/> * ================================================<br/> * Copyright (c) 2010-2011 .All rights reserved.<br/> */ public class AClass implements Serializable { private static final long serialVersionUID = 6558544854955394381L; /** 类的名称 **/ private String name; /** 类开头的字母 **/ private String index; public AClass() { } public AClass(String name, String index) { this.name = name; this.index = index; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getIndex() { return index; } public void setIndex(String index) { this.index = index; } public void init() { System.out.println("在AClass中定义的初始化时调用的方法init..."); } public void destroy() { System.out.println("在AClass中定义的销毁时调用的方法destroy..."); } @Override public String toString() { return "AClass [index=" + index + ", name=" + name + "]"; } }
BClass.java
import java.io.Serializable; /** * 文件名称： com.stu.bean.BClass.java<br/> * 初始作者： Administrator<br/> * 创建日期： 2018-2-1<br/> * 功能说明：例子用到的第二个类 <br/> * =================================================<br/> * 修改记录：<br/> * 修改作者 日期 修改内容<br/> * ================================================<br/> * Copyright (c) 2010-2011 .All rights reserved.<br/> */ public class BClass implements Serializable { private static final long serialVersionUID = 7680390121166235795L; private String name; private int age; /** 引入一个AClass参数，用来测试注入操作 **/ private AClass aClass; public BClass() { } public BClass(String name, int age, AClass aClass) { super(); this.name = name; this.age = age; this.aClass = aClass; } public AClass getaClass() { return aClass; } public void setaClass(AClass aClass) { this.aClass = aClass; } 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 "BClass [aClass=" + aClass + ", age=" + age + ", name=" + name + "]"; } }
通过构造器进行实例化：applicationContext.xml
<!-- id:例子在bean中的名字,值不可重复 class:例子类的类型，在底层个，通过反射原理进行实例化。 scope:作用域范围，'singleton'为单例;'prototype'不为单例； init-method:初始方法名称，自定义。 destroy-method：销毁执行的方法名称。 lazy-init:懒加载 --> <!-- 接口和静态类无法通过Spring添加 --> <bean id="aClass" class="com.stu.bean.AClass" scope="singleton" init-method="init" destroy-method="destroy" lazy-init="default"></bean> <!-- 使用name声明 --> <bean name="aClss2" class="com.stu.bean.AClass"></bean> <!-- 实例化静态方法 ,以Calendar为例 ，Java中初始化为：new Calendar().getInstance(); factory-method:用于指定工厂中创建bean对象的工厂方法，必须是static修饰 --> <bean id="cal" class="java.util.Calendar" factory-method="getInstance"></bean> <!-- 1.创建实例工厂 --> <bean id="ggncal" class="java.util.GregorianCalendar"></bean> <!-- 2.指定实例工厂并调用其中的实例工厂方法来获取对象 --> <bean id="date" factory-bean="ggncal" factory-method="getTime"></bean>
Demo02.java
public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext( "classpath:applicationContext.xml"); // getBean中传入xml中的id属性 //aClass作用范围是单例的，所以内存地址是一致的 System.out.println(ac.getBean("aClass")); System.out.println(ac.getBean("aClass", AClass.class)); // 实例静态类 System.out.println(ac.getBean("cal", GregorianCalendar.class)); //实例工厂 System.out.println(ac.getBean("date",Date.class)); }
运行结果：
在AClass中定义的初始化时调用的方法init... AClass [index=null, name=null] AClass [index=null, name=null] java.util.GregorianCalendar[time=1517484929359,areFieldsSet=true,areAllFieldsSet=true,lenient=true,zone=sun.util.calendar.ZoneInfo[id="Asia/Shanghai",offset=28800000,dstSavings=0,useDaylight=false,transitions=19,lastRule=null],firstDayOfWeek=1,minimalDaysInFirstWeek=1,ERA=1,YEAR=2018,MONTH=1,WEEK_OF_YEAR=5,WEEK_OF_MONTH=1,DAY_OF_MONTH=1,DAY_OF_YEAR=32,DAY_OF_WEEK=5,DAY_OF_WEEK_IN_MONTH=1,AM_PM=1,HOUR=7,HOUR_OF_DAY=19,MINUTE=35,SECOND=29,MILLISECOND=359,ZONE_OFFSET=28800000,DST_OFFSET=0]
B.依赖注入（DI）
IOC:控制反转(Inversion of control),原本由Java代码创建类的实例的权利交给了Spring容器进行创建，原本有Java代码维护的对象之间的依赖关系交给Spring容器进行维护
IOC能够降低软件模块或组件之间的耦合度
DI:依赖注入(Dependency Injection),DI的原理就是将一起工作的具有关系的对象，通过构造方法参数或方法参数传入，建立关系，因此，容器的工作就是创建bean时注入那些依赖关系，DI是IOC一种体现。
（setter注入，构造器注入，自动装配）
applicationContext.xml 中添加
<!-- setter注入 --> <bean id="bClass" class="com.stu.bean.BClass"> <!-- property:表示JavaBean中要被注入的属性 name:属性名 value:属性值(简单类型的属性值) ref:属性值(关联的JavaBean类型的id) --> <property name="name" value="This is BClass"></property> <property name="age" value="1"></property> </bean> <!-- 对BClass中的AClass类型属性赋值 --> <bean id="a2" class="com.stu.bean.AClass"> <property name="name" value="This is a2"></property> <property name="index" value="A"></property> </bean> <bean id="b2" class="com.stu.bean.BClass"> <property name="name" value="This is b2"></property> <property name="age" value="1"></property> <!-- 使用ref传值 --> <property name="aClass" ref="a2"></property> </bean> <!-- 通过构造器注入 --> <!-- 通过构造函数实例化 index:参数位置 value:参数的值 --> <bean id="b3" class="com.stu.bean.BClass"> <constructor-arg index="0" value="This is b3"></constructor-arg> <constructor-arg index="1" value="1"></constructor-arg> <constructor-arg index="2" ref="a3"></constructor-arg> </bean> <bean id="a3" class="com.stu.bean.AClass"> <constructor-arg index="0" value="this is a3"></constructor-arg> <constructor-arg index="1" value="1"></constructor-arg> </bean> <!-- 自动注入 --> <!-- autowire="byName" : 属性名=Bean Id autowire="byType" : 如果有多个相同类型的bean都能匹配成功吗，则出现错误 --> <bean id="a4" class="com.stu.bean.AClass" autowire="byName"> <property name="name" value="this is a4"></property> <property name="index" value="A"></property> </bean>
Demo03.java
public static void main(String[] args) { ApplicationContext ac = new ClassPathXmlApplicationContext( "classpath:applicationContext.xml"); // 没有实现对AClass的属性赋值 System.out.println(ac.getBean("bClass")); // 对AClass属性赋值 System.out.println(ac.getBean("b2", BClass.class)); /** * 使用构造注入 */ System.out.println(ac.getBean("b3", BClass.class)); /** * 自动注入 */ System.out.println(ac.getBean("a4")); }
运行结果
在AClass中定义的初始化时调用的方法init... BClass [aClass=null, age=1, name=This is BClass] BClass [aClass=AClass [index=A, name=This is a2], age=1, name=This is b2] BClass [aClass=AClass [index=1, name=this is a3], age=1, name=This is b3] AClass [index=A, name=this is a4]