Spring--4.标签 生命周期 服务启动（bean管理xml）

1       常用属性，子标签

1.1  属性

 

1.2  子标签

1.3  作用域--scope属性

使用scope设置作用域

    singleton :默认，单例的,初始化创建bean，整个生命周期只创建一个bean

    prototype :原型的，初始化不创建bean，每次请求创建一个bean，并返回

 

 

1.4  字面值—处理特殊字符

       字面值：可用字符串表示的值，可以通过 <value> 元素标签或 value 属性进行注入。

       若字面值中包含特殊字符，可以使用 <![CDATA[]]> 把字面值包裹起来。

<value><![CDATA[<北京>]]></value>

 

 

2       Bean 的生命周期-- init-method和destroy-method

2.1  生命周期方法

 

       SpringIOC 容器可以管理 Bean 的生命周期, Spring 允许在 Bean 生命周期的特定点执行定制的任务.

       SpringIOC 容器对 Bean 的生命周期进行管理的过程:

1.        通过构造器或工厂方法创建Bean 实例

2.        为 Bean 的属性设置值和对其他 Bean 的引用

3.        调用 Bean 的初始化方法

4.        Bean 可以使用了

5.        当容器关闭时, 调用 Bean 的销毁方法

       在 Bean 的声明里设置 init-method 和 destroy-method 属性, 为 Bean 指定初始化和销毁方法.

<bean id="car" class="spring.cycle.Car"init-method="init"destroy-method="destory">
       <property name="brand"value="奥迪"></property>
    </bean> 

2.2  创建 Bean 后置处理器

 

       Bean后置处理器允许在调用初始化方法前后对 Bean 进行额外的处理.

       Bean后置处理器对 IOC 容器里的所有 Bean 实例逐一处理, 而非单一实例. 其典型应用是: 检查 Bean 属性的正确性或根据特定的标准更改 Bean 的属性.

       对Bean 后置处理器而言, 需要实现BeanPostProcessor接口. 在初始化方法被调用前后, Spring 将把每个 Bean 实例分别传递给上述接口的以下两个方法:

 

<!-- 配置bean的后置处理器 -->
    <bean class="spring.cycle.MyBeanPostProcessor"></bean>

bean-cycle.xml

<?xml version="1.0"encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.0.xsd">
 
    <bean id="car"class="spring.cycle.Car" init-method="init" destroy-method="destory">
       <property name="brand"value="奥迪"></property>
    </bean>
 
    <!--
    实现 BeanPostProcessor
       postProcessBeforeInitialization(Objectbean, String beanName)：init-method()之前
       postProcessAfterInitialization(Objectbean, String beanName)：init-method()之后
       的实现：
   
    bean：bean的实例本身
    beanName：IOC容器的 bean 名字
    返回值：是实际上返回给用户那个bean，注意：可以修改bean，对应好就行，甚至返回一个新的 bean
    -->
    <!-- 配置bean的后置处理器：不需要配置ID， IOC容器自动识别是一个  BeanPostProcessor-->
    <bean class="spring.cycle.MyBeanPostProcessor"></bean>
 
</beans>

MyBeanPostProcessor

package spring.cycle;
 
import org.springframework.beans.BeansException;
importorg.springframework.beans.factory.config.BeanPostProcessor;
 
public class MyBeanPostProcessor implements BeanPostProcessor {
 
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName)
           throws BeansException {
       System.out.println("postProcessAfterInitialization:" + bean +","+beanName);
       Car car = new Car();
       car.setBrand("宝马");
       return car;
    }
 
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName)
           throws BeansException {
       System.out.println("postProcessBeforeInitialization:" + bean +","+beanName);
      
      
       return bean;
    }
}

Car

package spring.cycle;
 
public class Car {
 
    private String brand ;
   
    public String getBrand() {
       return brand;
    }
 
    public void setBrand(String brand) {
       System.out.println("为属性赋值：setBrand..."+brand);
       this.brand = brand;
    }
   
    public Car() {
       System.out.println("Car启动...");
    }
 
    public void init(){
       System.out.println("初始化...");
    }
   
    public void destory(){
       System.out.println("销毁...");
    }
 
    @Override
    public String toString() {
       return "Car[brand=" + brand + "]";
    }
}

2.3  添加 Bean 后置处理器后 Bean 的生命周期

过程：

1.        通过构造器或工厂方法创建Bean 实例

2.        为 Bean 的属性设置值和对其他 Bean 的引用

3.        将 Bean 实例传递给 Bean 后置处理器的postProcessBeforeInitialization 方法

4.        调用 Bean 的初始化方法

5.        将 Bean 实例传递给 Bean 后置处理器的postProcessAfterInitialization方法

6.        Bean 可以使用了

7.        当容器关闭时, 调用 Bean 的销毁方法

 

 

 

3      缓存—随tomcat启动

3.1  问题来源

撸主公司接了个小项目，有一张字典表会反复使用，如果去反复查询数据库，有点得不偿失，然而使用redis就有点大材小用，就想到用static属性在java里面弄一个map集合，就可以实现

 

3.2  第一步 在spring中配置前置方法

在applicationContext.xml文件添加前置方法，注意属性

<bean class="com.kun.devlop.service.CacheService"init-method="initMethod"></bean>

 

3.3  第二步 实现类（建议单例模式）

3.3.1      定义一个静态CACHE缓存变量

 

private staticMap<String, List<Map<String, Object>>> CACHE = new HashMap<String,List<Map<String, Object>>>();

3.3.2      前置方法

 

3.3.3      完整参考代码

public classCacheService {
 
   @Autowired
   private MetaTableFieldDao metaTableFieldDao;
 
   @Autowired
   private SqlQuery sqlQuery;
 
   private static Map<String,List<Map<String, Object>>> CACHE = new HashMap<String, List<Map<String,Object>>>();
 
   public void initMethod(){
      //1.获得所有不重复FieldMapping
      List<String>fieldMappings= metaTableFieldDao.findDisFieldMapping();
     
      if (fieldMappings != null && fieldMappings.size() > 0) {
         for (String  fieldMapping : fieldMappings){
            if (fieldMapping != null &&  !"".equals(fieldMapping)&& !"0".equals(fieldMapping)) {
                StringmetaTableSql= "SELECT code, name, pinyin FROMfield_mapping  where catalog_code ='" + fieldMapping + "'";
                List<Map<String,Object>> list= sqlQuery.query(metaTableSql,"");
                if (list != null && list.size() > 0) {
                   CACHE.put(fieldMapping, list);
                }
            }
         }
      }
      System.out.println(CACHE.get("AFLB"));
   }
}