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} \u6B22\u8FCE\u60A8
loginTitle={0},\u606D\u559C\u60A8,{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>