创建一个简单spring实例，spring单例与多例，初始化与销毁

Biegral 2020/9/8 9:12:46 6173

（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);
		
	}

}

这是多例的结果：


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();
		
	}

}

结果：




本文转载:CSDN博客

阅读排行

分类

归档