（1）在配置完spring提示框架后（上一遍文章有介绍），首先创建一个项目，导入sprig所需的jar包
然后书写主配置文件applicationContext.
<?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-2.5.xsd">
<!-- bean:将一个类的对象创建过程交给spring容器
class：指定类的具体路径
id：唯一标识符
-->
<bean id="yellowMouseWolf" class="cn.java.ioc1.YellowMouseWolf" ></bean>
</beans>
又创建了一个window类，用来测试：
package cn.java.ioc1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Window {
public static void main(String[] args) {
//启动框架(context代表spring容器)
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
//获取spring容器中创建的对象(通过id值获取)
YellowMouseWolf yello1=(YellowMouseWolf)context.getBean("yellowMouseWolf");
yello1.behavior();
}
}
package cn.java.ioc1;
public class YellowMouseWolf {
public YellowMouseWolf() {
System.out.println("YellowMouseWolf----黄鼠狼出生");
}
public void behavior() {
System.out.println("吃鸡");
}
}
如上便是一个简单的实例。
（2）单例与多例
创建一个Dog
package cn.java.singleton2;
public class Dog {
public Dog() {
System.out.println("一直狗狗诞生了");
}
public void behavior() {
System.out.println("狗会叫");
}
}
配置文件，这里设置为多例
<?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-2.5.xsd">
<!-- bean:将一个类的对象创建过程交给spring容器
class：指定类的具体路径
id：唯一标识符
scope:用来控制spring容器产生对象的方式，可以为单例也可以为多例。
常用的值为singleton(单例),prototype(多例)，默认的是单例
-->
<bean id="dog" class="cn.java.singleton2.Dog" scope="prototype" ></bean>
</beans>
创建一个调用的类
package cn.java.ioc1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.java.singleton2.Dog;
public class Window {
public static void main(String[] args) {
//启动框架(context代表spring容器)
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
//获取spring容器中创建的对象(通过id值获取)
Dog dog1=(Dog)context.getBean("dog");
Dog dog2=(Dog)context.getBean("dog");
Dog dog3=(Dog)context.getBean("dog");
//获得各自地址
System.out.println(dog1);
System.out.println(dog2);
System.out.println(dog3);
}
}
这是多例的结果：
扫描二维码关注公众号，回复：
1056328 查看本文章
dog1，dog2，dog3分别获得了数据，而且这三个的地址不同。
这是单例的配置：
<?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-2.5.xsd">
<!-- bean:将一个类的对象创建过程交给spring容器
class：指定类的具体路径
id：唯一标识符
scope:用来控制spring容器产生对象的方式，可以为单例也可以为多例。
常用的值为singleton(单例),prototype(多例)，默认的是单例
-->
<bean id="dog" class="cn.java.singleton2.Dog" ></bean>
</beans>
结果如下：只输出一个数据，而且地址相同。
（3）初始化
先看配置信息
<?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-2.5.xsd">
<!-- bean:将一个类的对象创建过程交给spring容器
class：指定类的具体路径
id：唯一标识符
scope:用来控制spring容器产生对象的方式，可以为单例也可以为多例。
常用的值为singleton(单例),prototype(多例)，默认的是单例
init-method:表示初始化方法，只写初始化方法的名字，不用加上();
-->
<bean id="smallJi" class="cn.java.initAndDistroy.ji" init-method="init"></bean>
</beans>
再看一个类：
package cn.java.initAndDistroy;
public class Ji {
public Ji() {
System.out.println("ji..........鸡出生了");
}
public void init() {
System.out.println("ji.......我是初始化方法");
}
public void behavior() {
System.out.println("鸡会打鸣");
}
}
以及一个调用类：
package cn.java.ioc1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.java.initAndDistroy.Ji;
import cn.java.singleton2.Dog;
public class Window {
public static void main(String[] args) {
//启动框架(context代表spring容器)
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
//获取spring容器中创建的对象(通过id值获取)
Ji ji=(Ji)context.getBean("smallJi");
ji.behavior();
}
}
结果如下：
我们看出，先执行构造方法，然后执行的是初始化方法。
销毁：
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-2.5.xsd">
<!-- bean:将一个类的对象创建过程交给spring容器
class：指定类的具体路径
id：唯一标识符
scope:用来控制spring容器产生对象的方式，可以为单例也可以为多例。
常用的值为singleton(单例),prototype(多例)，默认的是单例
init-method:表示初始化方法，只写初始化方法的名字，不用加上();
destroy-method是销毁方法。--> <bean id="smallJi" class="cn.java.initAndDistroy.ji" init-method="init" destroy-method="destroy"></bean> </beans>
package cn.java.initAndDistroy;
public class Ji {
public Ji() {
System.out.println("ji..........鸡出生了");
}
public void init() {
System.out.println("ji.......我是初始化方法");
}
public void behavior() {
System.out.println("鸡会打鸣");
}
//销毁
public void destroy() {
System.out.println("ji........鸡挂了");
}
}
package cn.java.ioc1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import cn.java.initAndDistroy.Ji;
import cn.java.singleton2.Dog;
public class Window {
public static void main(String[] args) {
//启动框架(context代表spring容器)
ApplicationContext context=new ClassPathXmlApplicationContext("applicationContext.xml");//只写这句也可以调用YellowMouseWolf类中的无参构造方法
//获取spring容器中创建的对象(通过id值获取)
Ji ji=(Ji)context.getBean("smallJi");
ji.behavior();
//关闭context容器，并且销毁容器中所有的对象
((ClassPathXmlApplicationContext) context).close();
}
}
结果：
