Spring框架总结(二)

目录

开发一个简单的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方法时候执行，(容器用实现类)
posted @ 2017-03-10 21:31  北极的大企鹅  阅读(188)  评论(0)  编辑  收藏  举报
阅读 - 79万