Spring零碎知识复习

自学了Spring也有一段时间了，多多少少掌握了一些Spring的知识，现在手上也没有很多的项目练手，就将就着把这些学到的东西先收集起来，方便日后用到的时候没地方找。

1、spring的国际化

主要是配置文件：

<bean id="messageSource"
        class="org.springframework.context.support.ResourceBundleMessageSource">
        
        <!-- 传入资源文件 -->
        <!-- 类中的方法加载资源文件 setBasenames (String[] basenames) -->
        <!-- 该方法的参数为数组  利用list -->
        <property name="basenames">
            <list>
                <value>mess</value>
            </list>
        </property>
</bean>

获取国际化信息：

 System.out.println(cfx.getMessage("hello", new String[]{"chentao"},Locale.US));//第一个参数为key,第二个参数表示占位符，第三个参数表示Locale 两个国际化资源文件 

mess_en_US.properties

hello={0} hello,you are welcome
loginTitle={0},congratulations,{1}

mess_zh_CN.properties

hello={0} u6B22u8FCEu60A8
loginTitle={0},u606Du559Cu60A8,{1}

2、spring资源访问

　　　

        //加载资源功能
        Resource r = cfx.getResource("classpath:ct.txt");//从类加载路径
        
        BufferedReader br = new BufferedReader(new InputStreamReader(r.getInputStream()));
        String line = null;
        while((line = br.readLine())!=null){
            System.out.println(line);
        }

3、spring命名空间

配置文件的头部添加：

 xmlns:p="http://www.springframework.org/schema/p" 

4、spring嵌套Bean、依赖注入集合：

<bean id="person" class="com.csu.spring.domain.Person">
        <!-- 嵌套bean -->
        <property name="userDao">
            <bean class="com.csu.spring.dao.UserDaoHibernate"/>    
        </property>
        
        <property name="schools">
            <list>
                <value>小学</value>  <!-- String为标量类型，用value表示 -->
                <value>中学</value>
                <value>大学</value>
            </list>
        </property>
        
        <property name="scores">
            <map>
                <entry key="数学" value="98.9" />
                <entry key="语文" value="88" />            
            </map>
        </property>
        
        <property name="health">
            <props>
                <prop key="姓名">**</prop>
                <prop key="年龄">20</prop>
            </props>
        </property>
        
        
        <property name="items">
            <set>
                <value>我的电脑</value>
                <list>
                    <value>笔记本</value>
                </list>
            </set>
        </property>

</bean>

5、利用静态工厂方法和实例工厂方法实例化Bean对象：

配置文件

    <!-- 利用静态工厂方法实例化Bean对象 -->
    <!--
    当设置了factory-method属性之后，
    userService_2 = com.csu.spring.service.UserServiceFactory.createUserService()
     -->
    <bean id="userService_2"
          class="com.csu.spring.service.UserServiceFactory"
          factory-method="createUserService">
          <!-- 如果工厂方法有参数，通过constructor-arg元素传入 -->
          <constructor-arg value="陈涛"/>      
    </bean>

     <!-- 实例工厂方法 -->
    <bean id="userServiceFactory" class="com.csu.spring.service.UserServiceFactory"/>
    <bean id="userService_3" factory-bean="userServiceFactory" factory-method="createUserService_2"/>

工厂类：

public class UserServiceFactory {
    
    //利用静态工厂方式实例化Bean,,以前在配置文件中都是调用Bean实现类的构造器
    
    //假定有参数
    public static UserService createUserService(String name){
        System.out.println("参数值为：" +name +"*********静态工厂方法*************");
        return new UserService();
    }
    
    public UserService createUserService_2(){
        System.out.println("*********实例工厂方法*************");
        return new UserService();
    }

}

6、抽象Bean:

   <!-- 因为模板只是一些通用的信息，所以告诉Sring不要创建Bean模板的实例，
    增加abstract="true" -->
    <bean id="template" abstract="true">
        <property name="school" value="csu"></property>
    </bean>

<bean id="person" class="com.csu.spring.doamin.Person" parent="template"...(略)...>

7、协调作用域不同的Bean

先简单介绍一下Bean的生命周期：

Bean有4个作用域：Singleton Prototype Request Session

当Singleton的Bean依赖Prototype的Bean，由于Singleton只有一次初始化机会，这样就会导致Singleton的Bean永远依赖于最开始的注入的Prototype的Bean

解决办法：

（1）放弃依赖注入：

自定义一个方法，即Spring容器在获取singleton Bean时，都重新从Spring容器中获取一个Prototype Bean， 那么该方法要首先获取Spring容器，再获取并返回Prototype Bean：

singleton Bean要实现ApplicationContextAware接口：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;

public class Person implements ApplicationContextAware{

    private ApplicationContext cxt;
    
  
    private Cat cat;
   
    
    public void setCat(Cat cat) {
        this.cat = cat;
    }
   
    
    //解决bean作用域不同步的问题
    public Cat createCat(){
        //调用Spring容器重新获取prototype的Bean
        return (Cat) cxt.getBean("cat");
    }
   
    public void getcat(){
        System.out.println("得到猫的种类： "+createCat());
    }
   
    //该方法由Spring调用，而且Spring把自身作为参数传入
    @Override
    public void setApplicationContext(ApplicationContext arg0) throws BeansException {
        // TODO Auto-generated method stub
        this.cxt = arg0;
    }
    
}

（2）使用Lookup注入：

public abstract class Person {

   
    private Fish fish;
   
    
    public void setFish(Fish fish) {
        this.fish = fish;
    }
  
  
    public abstract Fish createFish();
    
  
    public void getFish(){
        System.out.println("得到鱼的种类：" + createFish());
    }
   
    
}

   

    <bean id="fish" class="com.csu.spring.doamin.Fish" scope="prototype"/>
    
    <bean id="person" class="com.csu.spring.doamin.Person" parent="template">
          
        <lookup-method name = "createFish" bean="fish"/>
        
　  </bean>

lookup-method元素告诉Spring，需要先创建Person的子类，而且该子类要实现name指定的方法，这样每次在调用Person Bean的时候，都会得到新的Fish Bean.

8、FactoryBean:

FactoryBean接口是工厂Bean的标准接口，实现该接口的Bean通常作为工厂Bean使用，当我们把工厂Bean部署在容器中，并通过getBean方法来获取时，容器不会返回FactoryBean实例，

而是返回FactoryBean产品。

import org.springframework.beans.factory.FactoryBean;

//用于返回指定类，指定静态field的值
public class GetFieldFactoryBean implements FactoryBean {

    private String field;
    private String targetClass;
    

    public void setField(String field) {
        this.field = field;
        
    }

    
    
    public void setTargetClass(String targetClass) {
        this.targetClass = targetClass;
        
        
    }



    //获取返回值
    @Override
    public Object getObject() throws Exception {
        // TODO Auto-generated method stub
        //return "hello world ";
        Class clazz = Class.forName(targetClass);
        
        //返回clazz类的field的值
        return clazz.getField(field).get(clazz);
    }

    //判断返回值的类型
    @Override
    public Class getObjectType() {
        // TODO Auto-generated method stub
        return null;
    }

    //判断是否是单例
    @Override
    public boolean isSingleton() {
        // TODO Auto-generated method stub
        return false;
    }
}

     <!--
     如果GetFieldFactoryBean实现了FactoryBean接口。
     那么下面的代码等于：
     创建实例后，
     getFieldFactoryBean = com.csu.spring.util.GetFieldFactoryBean.getObject()
     -->
    <bean id="getFieldFactoryBean" class="com.csu.spring.util.GetFieldFactoryBean"
        p:field="out" p:targetClass="java.lang.System">
    </bean>

9、Spring调用get方法

<?xml version="1.0" encoding="UTF-8"?>

<!-- 整个Spring 文件的根元素就是beans -->
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:util="http://www.springframework.org/schema/util"
    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.xsd
        
        http://www.springframework.org/schema/util
        http://www.springframework.org/schema/util/spring-util.xsd">
        
  <bean id="person" class="com.csu.spring.getter_test.Person" scope="prototype">  
     <property name="age">  
        <value>30</value>  
     </property>
      
     <property name="son">  
        <bean class="com.csu.spring.getter_test.Son">  
           <property name="age">  
              <value>16</value>  
           </property>  
        </bean>  
     </property>  
  </bean>  
    
  <!--如下将会将person的属性son的属性age传入son1实例的age属性-->  
    <bean id="son1" class="com.csu.spring.getter_test.Son">  
        <property name="age">  
          <!--以下是访问bean属性的简单方式,这样可以将person这个bean的age属性赋值给son1这个bean的age属性-->
          <!-- 此处的id是指person.getSon().getAge()的返回值 -->            
         <bean id="person.son.age" class="org.springframework.beans.factory.config.PropertyPathFactoryBean"/>  
        </property>  
    </bean>  
      
    <!-- 以下将会获得结果son,它将是person bean的son的数值-->  
    <bean id="son2" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">  
       <property name="targetBeanName">  
         <value>person</value>  
       </property>  
       <property name="propertyPath">  
         <value>son</value>  
       </property>  
    </bean>  
      
     <!-- 以下将会获得结果16,它将是person bean的son的age属性-->  
    <bean id="son3" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">  
       <property name="targetBeanName">  
         <value>person</value>  
       </property>  
       <property name="propertyPath">  
         <value>son.age</value>  
       </property>  
    </bean>  
      
    <!-- 以下会获得结果为30 ,它将是获得该bean的内部bean的age属性-->  
    <bean id="son4" class="org.springframework.beans.factory.config.PropertyPathFactoryBean">  
        <property name="targetObject">  
            <bean class="com.csu.spring.getter_test.Person">  
                <property name="age">
                    <value>30</value>
                </property>  
            </bean>  
        </property>  
        <property name="propertyPath">
            <value>age</value>
        </property>  
    </bean>  
    
    <!--访问实例Field的 -->
    <bean id="dog" class="com.csu.spring.getter_test.Dog" p:age="2"/>
    <bean id="age" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
        p:targetObject-ref="dog" p:targetField="age"/>
        
    <!-- 调用普通方法 -->
    <bean id="jf" class="javax.swing.JFrame" p:title="我的窗口"/>    
    <bean class="org.springframework.beans.factory.config.MethodInvokingBean"
    p:targetObject-ref="jf"
    p:targetMethod="setBounds"><!-- targetMethod就是指定方法名 ，不要对方法名进行任何修改-->
        <property name="arguments">
            <list>
                <value>40</value>
                <value>40</value>
                <value>200</value>
                <value>300</value>
            </list>
        </property>
    </bean>
    <bean class="org.springframework.beans.factory.config.MethodInvokingBean"
    p:targetObject-ref="jf"
    p:targetMethod="add"><!-- targetMethod就是指定方法名 ，不要对方法名进行任何修改-->
        <property name="arguments">
            <list>
                <bean class="javax.swing.JButton">
                    <constructor-arg value="文本框"/>
                </bean>
                <value>North</value>
            </list>
        </property>
    </bean>
    
    <bean class="org.springframework.beans.factory.config.MethodInvokingBean"
    p:targetObject-ref="jf"
    p:targetMethod="add"><!-- targetMethod就是指定方法名 ，不要对方法名进行任何修改-->
        <property name="arguments">
            <list>
                <bean class="javax.swing.JButton">
                    <constructor-arg  value="我的按钮"/>
                </bean>
                
                <value>South</value>
            </list>
        </property>
    </bean>
    
    
    <bean class="org.springframework.beans.factory.config.MethodInvokingBean"
    p:targetObject-ref="jf"
    p:targetMethod="setVisible"><!-- targetMethod就是指定方法名 ，不要对方法名进行任何修改-->
        <property name="arguments">
            <list>
                <value>true</value>
            </list>
        </property>
    </bean>
    
    <bean id="out" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
        p:targetClass="java.lang.System"
        p:targetField="out"/>
        
    <util:constant id="out2" static-field="java.lang.System.out" />
    <util:constant id="out3" static-field="java.sql.Connection.TRANSACTION_SERIALIZABLE"/>
    <util:property-path id="pAge" path="person.age"/>
    <util:list id="mylist" list-class="java.util.ArrayList">
        <value>哈哈</value>
        <bean class="java.util.Date"></bean>       
        <value></value>
    </util:list>
    
    
</beans>