Spring-01-HelloWorld

传统的HelloWorld

编写java类

package com.weixuan.spring;

public class HelloWorld {

public void hello() {
System.out.println("Hello World .");
}

public static void main(String[] args) {
}
}

编译成.class文件

使用classloader加载class到jvm中

new一个实例

所有的过程全程参与

使用Spring的HelloWorld

写一个java类

编写配置文件，将类放入spring容器

启动spring 容器 (在类路径下寻找配置文件来实例化容器)

从容器中取出java类

对象.方法

控制翻转的概念：把对象的创建，初始化，销毁等动作交给spring 容器来做，由spring容器来控制对象的生命周期。注意：销毁是在scope是单例的情况下

HelloWorld实例

HelloWorld类

package com.weixuan.spring;

public class HelloWorld {

/**
* 属性是共享的，可能会引发线程安全问题
*/
public void hello() {
System.out.println("Hello World .");
}
}

配置文件

<?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"> 
<!-- 把一个类放在spring容器中，该类就成为bean id 的首字母小写-->
<bean id="helloWorld" class="com.weixuan.spring.HelloWorld">
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->

</beans>

客户端测试文件

- 启动ioc容器

- 取出类 helloworld

- 使用对象(对象.方法)

package com.weixuan.test;

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

import com.weixuan.spring.HelloWorld;

public class TestOfHelloWorld extends HelloWorld {

// 传统的写法
@Test
public void test() {
HelloWorld helloWorld = new HelloWorld();
helloWorld.hello();
}

// 使用IOC容器的写法

@Test
public void testIOC() {
/**
* 1、启动ioc容器 2、取出helloworld 3、对象.方法
*/
// 1、启动ioc容器
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"com/weixuan/spring/applicationContext.xml");

// 2、取出helloworld
HelloWorld helloWorld = (HelloWorld) applicationContext
.getBean("helloWorld");

// 3、对象.方法
helloWorld.hello();
}
}

scope属性

@Test
public void testSpring() {
ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"com/weixuan/spring/applicationContext.xml");

HelloWorld helloWorld1 = (HelloWorld) applicationContext
.getBean("helloWorld");
HelloWorld helloWorld2 = (HelloWorld) applicationContext
.getBean("helloWorld");

System.out.println(helloWorld1);
System.out.println(helloWorld2);
}

可以看出输出是一样的，说明是默认是单例模式

com.weixuan.spring.HelloWorld@42e366c1
com.weixuan.spring.HelloWorld@42e366c1

单例模式就要考虑线程安全问题，可以设置scope属性是原型模式

<bean id="helloWorld" class="com.weixuan.spring2.HelloWorld" scope="prototype"> </bean>

其他属性配置

init-method ： 在构造函数之后，有spring容器立即执行，此方法的目的是在构造函数之后，调用方法之前，做一些准备工作。

destroy-method：当scope设置为单例的时候，在spring容器关闭或者销毁的时候销毁这个方法。否则，关闭资源必须是开发者手动关闭。

测试文件

package com.weixuan.initdestory;

public class HelloWorld {

public HelloWorld() {
System.out.println("Default constructor ...");
}

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

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

public void hello() {
System.out.println("Hello World .");
}
}

<?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"> 
<!-- 把一个类放在spring容器中，该类就成为bean id 的首字母小写 -->

<!--
init-method ： 在构造函数之后，有spring容器立即执行
此方法的目的是在构造函数之后，调用方法之前，做一些准备工作

destroy-method：当scope设置为单例的时候，在spring容器关闭或者销毁的时候销毁这个方法
否则，关闭资源必须是开发者手动关闭
-->
<bean id="helloWorld" class="com.weixuan.initdestory.HelloWorld"
init-method="init" destroy-method="destory" >
<!-- collaborators and configuration for this bean go here -->
</bean>
<!-- more bean definitions go here -->

</beans>

测试文件及结果

package com.weixuan.test;

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

import com.weixuan.initdestory.HelloWorld;

public class TestOfInitDestory extends HelloWorld {

private ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
"com/weixuan/initdestory/applicationContext.xml");

@Test
public void test() {
HelloWorld helloWorld = (HelloWorld) applicationContext
.getBean("helloWorld");

helloWorld.hello();
/**
* 输出，并没有destory方法
* Default constructor ...
* init...
* Hello World .
*/
}

@Test
public void test2() {

ClassPathXmlApplicationContext classPathXmlApplicationContext = (ClassPathXmlApplicationContext)applicationContext;

HelloWorld helloWorld = (HelloWorld) classPathXmlApplicationContext
.getBean("helloWorld");

helloWorld.hello();
classPathXmlApplicationContext.close();

/**
* scope默认为单例模式
* 此时输出：
* Default constructor ...
* init...
* Hello World .
* ....
* destory...
*/

/**
* scope为prototype模式
* 输出
* Default constructor ...
* init...
* Hello World .
*/
}
}

这就是最简单的HelloWorld