开发一个简单的Spring项目
一、开发环境搭建
- 引入源码jar ：3.0以前的版本含有依赖jar包，3.0以后只有spring的核心jar包
| 核心的jar包 | commons-logging-1.1.3.jar spring-beans-3.2.5.RELEASE.jar spring-context-3.2.5.RELEASE.jar spring-core-3.2.5.RELEASE.jar spring-expression-3.2.5.RELEASE.jar |
|---|---|
| jar包可以在官网下载 | http://repo.spring.io/release/org/springframework/spring/ |
二、开发流程
-
1、创建一个xml文档，命名为applicationContext.xml
- 导入必须的schema
1 <beans xmlns="http://www.springframework.org/schema/beans"
2 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3 xmlns:p="http://www.springframework.org/schema/p"
4 xmlns:context="http://www.springframework.org/schema/context"
5 xsi:schemaLocation="
6 http://www.springframework.org/schema/beans
7 http://www.springframework.org/schema/beans/spring-beans.xsd
8 http://www.springframework.org/schema/context
9 http://www.springframework.org/schema/context/spring-context.xsd">
10
11 </beans>
-
2、创建例子
user
1 package com.baba.spring;
2
3 public class User {
4 String _id;
5 String _username;
6
7 public User() {
8 System.out.println("========创建类========");
9 }
10
11 public String get_id() {
12 return _id;
13 }
14
15 public void set_id(String _id) {
16 this._id = _id;
17 }
18
19 public String get_username() {
20 return _username;
21 }
22
23 public void set_username(String _username) {
24 this._username = _username;
25 }
26 }
- 3、创建xml
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
4 xmlns:context="http://www.springframework.org/schema/context"
5 xsi:schemaLocation="
6 http://www.springframework.org/schema/beans
7 http://www.springframework.org/schema/beans/spring-beans.xsd
8 http://www.springframework.org/schema/context
9 http://www.springframework.org/schema/context/spring-context.xsd">
10 <bean id="user" class="com.baba.spring.User"></bean>
11
12
13
14 </beans>
- 4、创建测试类
1 @SuppressWarnings({ "resource", "deprecation" })
2 public class TestApplication {
3
4 // 通过工厂类创建IOC工程类对象
5 @Test
6 public void test1() {
7 // 把对象创建交给IOC
8 Resource resource = new ClassPathResource("com/baba/spring/applicationContext.xml");
9 // 创建器对象
10 BeanFactory beanFactory = new XmlBeanFactory(resource);
11 // 的到容器对象 IOC=工厂类+ApplicationContext.xml
12 User user = (User) beanFactory.getBean("user");
13
14 System.out.println(user);
15 }
16
17 // 2.直接获取ApplicationContext.xml()方便
18 @Test
19 public void test2() {
20
21 ApplicationContext aContext = new ClassPathXmlApplicationContext(
22 "com/baba/spring/applicationContext.xml");
23
24 // 的到容器对象 IOC=工厂类+ApplicationContext.xml
25 User user = (User) aContext.getBean("user");
26
27 System.out.println(user);
28 }
29
30 @Test
31 public void test3() {
32 /*
33 * (1)修改
34 * <bean id="user" class="com.baba.spring.User" scope="singleton"></bean>
35 * // scope="singleton" scope属性的singleton(单利模式)加不加无影响,默认是单例模式 使用在与[service/dao/工具类]连接操作这样的连接类只需创建一次的情况
36 * (2)scope="prototype" 多例 用途:(1)用在类似[action对象]这样有多次创建对象时使用 (2)还有用到对象时创建 启动容器之前,整个应用只有一个
38 * (3)是否延迟创建
39 * scope="singleton" 才有效
40 * (4)懒加载问题 lazy-init="false" 默认为false, 使用懒加载就是在用到对象的时候才创建对象,改为true的时候才有效
41 * 不延迟创建，
42 * 即在启动时候就创建对象 lazy-init="true" 延迟初始化， 在用到对象的时候才创建对象
43 *
44 *
45 * (5) lazy-init要与scope="single"一起使用 当lazy-init="true"+scope="singleton" 效果跟单独设置scope="prototype"一样
46 * lazy-init对多例无影响
*/
47 ApplicationContext aContext = new ClassPathXmlApplicationContext(
48 "com/baba/spring/applicationContext.xml");
49 System.out.println("========创建容器========");
50 // 得到容器对象 IOC=工厂类+ApplicationContext.xml
51 User user1 = (User) aContext.getBean("user");
52 User user2 = (User) aContext.getBean("user");
53
54 System.out.println(user1);
55 System.out.println(user2);
56 }
57
58 }
| 单例模式 | 在容器创建之前就创建了对象,而且只创建一次 |
|---|---|
| 多例模式 | 在容器创建之后创建类,可以多次创建类 |
三、初始化和销毁测试:
- 在user类中加入两个方法
1 public class User1 {
2 String _id;
3 String _username;
4
5 public void init_user() {
6 System.out.println("创建对象之后,初始化");
7 }
8
9 public void destroy_user() {
10 System.out.println("IOC容器销毁对象,user对象回收");
11 }
12
13 public User1() {
14 System.out.println("========User1创建类========");
15 }
16
17 public String get_id() {
18 return _id;
19 }
20
21 public void set_id(String _id) {
22 this._id = _id;
23 }
24
25 public String get_username() {
26 return _username;
27 }
28
29 public void set_username(String _username) {
30 this._username = _username;
31 }
32
33 }
- 然后再.xml文档中加入两个属性init-method和destroy-method="destroy_user"
1 <?xml version="1.0" encoding="UTF-8"?>
2 <beans xmlns="http://www.springframework.org/schema/beans"
3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
4 xmlns:context="http://www.springframework.org/schema/context"
5 xsi:schemaLocation="
6 http://www.springframework.org/schema/beans
7 http://www.springframework.org/schema/beans/spring-beans.xsd
8 http://www.springframework.org/schema/context
9 http://www.springframework.org/schema/context/spring-context.xsd">
10 <bean id="user" class="com.baba.spring.User" scope="singleton" lazy-init="true"></bean>
11 <bean id="user1" class="com.baba.destroy.User1" init-method="init_user"
12 destroy-method="destroy_user"></bean>
13
14 </beans>
- 编写测试类
1 @Test
2 public void test2() {
3
4 ClassPathXmlApplicationContext aContext = new ClassPathXmlApplicationContext(
5 "com/baba/destroy/applicationContext.xml");
6 System.out.println("======User1==创建容器========");
7 // 的到容器对象 IOC=工厂类+ApplicationContext.xml
8 User1 user1 = (User1) aContext.getBean("user1");
9
10 System.out.println(user1);
11 aContext.destroy();
12 }
四、使用场景
-
创建对象之后，初始化/销毁
名称 描述 init-method="init_user" 对应对象的init_user方法，在对象创建爱之后执行 destroy-method="destroy_user" 在调用容器对象的destriy方法时候执行，(容器用实现类)
