Attempt-Spring-1：笔记

Attempt-Spring-1：笔记

 

 

代码：

 

Books.java:

 


package qau.edu;

 

publicclass Books {

 

   privateintNumber ;

   private String name;

   privatedoubleprice ;

   publicint getNumber() {

      returnNumber;

   }

   publicvoid setNumber(int number) {

      Number = number;

   }

   public String getName() {

      returnname;

   }

   publicvoid setName(String name) {

      this.name = name;

   }

   publicdouble getPrice() {

      returnprice;

   }

   publicvoid setPrice(double price) {

      this.price = price;

   }

  

  

}

 

 

 

配置文件代码：

 


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

<beans xmlns="http://www.springframework.org/schema/beans"

   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">

 

 

   <bean id="book1" class="qau.edu.Books">

 

      <property name="name">

 

         <value><![CDATA[《指环王》]]></value>

 

      </property>

 

      <property name="price" value="39.23" />

 

      <property name="number" value="10002" />

 

   </bean>

 

</beans>

 

 

  1. 1.       bean.xml的配置文件只能放在src的根文件下；
  2. 2.       关于特殊的字符，必须放在“<![CDATA[]]>”之中；
  3. 3.       上面的Spring是基于“属性设值”的前提之下的，所以在配置中用的是setter对应的“<property>”节点；

 

编写测试类：

 


package qau.edu;

 

 

import java.io.IOException;

import java.lang.annotation.Annotation;

import java.util.Locale;

import java.util.Map;

 

import org.junit.Test;

import org.springframework.beans.BeansException;

import org.springframework.beans.factory.BeanFactory;

import org.springframework.beans.factory.NoSuchBeanDefinitionException;

import org.springframework.beans.factory.config.AutowireCapableBeanFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationEvent;

import org.springframework.context.MessageSourceResolvable;

import org.springframework.context.NoSuchMessageException;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import org.springframework.core.env.Environment;

import org.springframework.core.io.Resource;

 

publicclass SpringTest {

 

  

  

// 传统的方式；

  

   @Test

   publicvoid test1() {

     

//    实例化对象；

     

      Books  bo1 = new Books();

     

//    进行初始化；

     

      bo1.setName("基督山伯爵");

      bo1.setNumber(100001);

      bo1.setPrice(35.2);

     

//    进行输出；

     

      System.out.println("书籍的信息：\n\n\n书籍的名字是：" + bo1.getName() + ",书籍的代号是："

                           + bo1.getNumber() + "，书籍的价格是：" + bo1.getPrice());

     

   }

  

  

  

// 通过Spring；

  

  

   @Test

   publicvoid test2(){

     

//    创建applicationcontext对象；

     

      ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

     

//    获取对象；

     

      Books bo1 = (Books)ctx.getBean("book1");

     

//    输出信息；

     

      System.out.println("书籍的信息：\n" + "名字是：" + bo1.getName() + ",价格：" + bo1.getPrice());

        

        

     

  

 

}

  

}

 

总结：

 

 上面单元测试类中用的是两种方式进行的对抽象的类进行的处理，比较两种方式，就能很好的理解Spring框架的意义；

  第一种是传统的方式，即，将.java文件下的类的定义的雏形进行初始化，在main（）方法下要出现“显式”的实例化和进行设置属性的代码语句；

  第二种方式之下，是通过Spring框架进行的初始化和设置的操作的（根据bean中配置的信息），在进行IOC容器的创建的时候，也就是实现ApplicationContext接口时候，他会同时的进行类的创建（对象的初始化），然后根据bean文件提供的信息进行相应的实例化。可以通过代码演示：

 

为了测试方便对POJO进行了修改；

 


 

package qau.edu;

public class Books {

private int Number ;

private String name;

private double price ;

public int getNumber() {

System.out.println("调用的是getter方法、、、、、");

return Number;

}

public void setNumber(int number) {

System.out.println("调用的是setter方法、、、、、、");

Number = number;

}

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

public double getPrice() {

return price;

}

public void setPrice(double price) {

this.price = price;

}

//  无参数的构造器；

public Books(){

System.out.println("调用的是无参数的构造方法方法、、、、、、、、、、");

}

}

 

 

 

 

测试类中把显式的实例化和设置属性的语句进行注释：

 


//  通过Spring；

@Test

public void test2(){

//     创建applicationcontext对象；

ApplicationContext ctx = new ClassPathXmlApplicationContext("bean.xml");

//     获取对象；

//     Books bo1 = (Books)ctx.getBean("book1");

//     输出信息；

//     System.out.println("书籍的信息：\n" + "名字是：" + bo1.getName() + ",价格：" + bo1.getPrice())

}

 

执行代码的结果：

 

 


十一月 21, 2014 5:31:09 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org[email protected]1e2b67c: startup date [Fri Nov 21 17:31:09 CST 2014]; root of context hierarchy

十一月 21, 2014 5:31:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

信息: Loading XML bean definitions from class path resource [bean.xml]

调用的是无参数的构造方法方法、、、、、、、、、、

调用的是setter方法、、、、、、

 

 

 

所以，是Spring对实例化进行了相应的封装处理；

 

 

 

 

（二）关于“构造注入”方式的演示：

 

配置文件：

 

Ren.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"

   xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

 

   <!-- 演示和验证构造注入的相关信息 -->

  

   <bean id="book1" class="qau.edu.Books">

    

        <constructor-arg value="10003"></constructor-arg>

       

         <constructor-arg>

        

            <value><![CDATA[《平凡的世界》]]></value>

        

         </constructor-arg>

        

         <constructor-arg value="23"></constructor-arg>

  

   </bean>

 

</beans>

 

 

 

测试代码：

 


// 测试"构造注入"；

  

   @Test

   publicvoid test4(){

     

     

//    创建applicationContext对象；

     

      ApplicationContext ctx2 = new ClassPathXmlApplicationContext("Ren.xml");

     

//    获取对象；

     

      Books book1 = (Books)ctx2.getBean("book1");

     

//    输出打印结果；

     

      System.out.println(book1);

   }

 

相应的Books.java中的构造方法

 


package qau.edu;

 

publicclass Books {

 

   privateintNumber;

   private String name;

   privatedoubleprice;

   privateintpage ;

 

   publicint getNumber() {

 

      System.out.println("调用的是getter方法、、、、、");

      returnNumber;

   }

 

   publicvoid setNumber(int number) {

 

      System.out.println("调用的是setter方法、、、、、、");

      Number = number;

   }

 

   public String getName() {

      returnname;

   }

 

   publicvoid setName(String name) {

      this.name = name;

   }

 

   publicdouble getPrice() {

      returnprice;

   }

  

 

   publicvoid setPrice(double price) {

      this.price = price;

   }

 

   // 无参数的构造器；

 

   publicint getPage() {

      returnpage;

   }

 

   publicvoid setPage(int page) {

      this.page = page;

   }

 

   public Books() {

 

      System.out.println("调用的是无参数的构造方法方法、、、、、、、、、、");

 

   }

 

   // 带有参数的构造方法；

   public Books(String name, double price){

      super();

     

      this.name = name;

      this.price = price;

     

   }

  

 

  

  

public Books(int number, String name, int page) {

      super();

      Number = number;

      this.name = name;

      this.page = page;

   }

 

 

 

// 编写toString()方法，用于测试方便；

  

  

@Override

public String toString() {

   return"Books [Number=" + Number + ", name=" + name + ", price=" + price

         + ", page=" + page + "]";

}

  

  

 

}

 

执行结果：

 


十一月 21, 2014 8:06:39 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org[email protected]1e2b67c: startup date [Fri Nov 21 20:06:39 CST 2014]; root of context hierarchy

十一月 21, 2014 8:06:39 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

信息: Loading XML bean definitions from class path resource [Ren.xml]

Books [Number=10003, name=《平凡的世界》, price=0.0, page=23]

 

 

小总结：

 

上面的文件中，在进行构造注入的前提之下需要进行相应的构造方法的编写，需要主要的是，在进行构造方法的编写时候，参数的列表中的属性的顺序要和bean文件中的<constructor-arg>中的顺序一样的。在Java中，区分方法重载的方法就是利用方法的签名区分的。这是为了避免出错的很好的方法也是在进行编写程序中很重要的。

还有注意的就是，在进行属性注入和构造注入的联合使用的时候，在.java 也就是POJO文件中要在编写构造注入的带有参数的构造方法的时候，还要进行无参数的构造方法的重写，这是因为在进行属性注入的时候，有一个前提条件就是，需要一个默认的构造方法，也就是无参数的构造方法。（这是很容易忽略的）

 

 

（三）、演示bean之间的关系；

 

1、 引用关系：

代码：

 

配置文件

 


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

<beans xmlns="http://www.springframework.org/schema/beans"

   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">

 

   <!-- 演示和验证构造注入的相关信息 -->

  

   <bean id="book1" class="qau.edu.Books">

    

        <constructor-arg value="10003"></constructor-arg>

         <constructor-arg>

        

            <value><![CDATA[《平凡的世界》]]></value>

        

         </constructor-arg>

         <constructor-arg value="23"></constructor-arg>

  

   </bean>

  

  

    <!--演示bean的之间的引用  -->

   

    <bean id="body1" class="qau.edu.Body">

   

      <property name="name" value="Kobe"></property>

      <property name="age" value="36"></property>

      <property name="sex" value="男"></property>

      <property name="book" ref="book1"></property>

      <property name="book.price" value="34.4"></property>

     

    </bean>

   

    <!-- 演示List集合属性 -->

   

    <bean id="person1" class="qau.edu.Person">

   

       <property name="name" value="AAA"></property>

       <property name="age" value="29"></property>

      

       <property name="books">

      

          <list>

             <ref bean="book1"/>

          </list>

      

       </property>

      

             

      

   

    </bean>

   

</beans>

 

 

 

 

 

 

 

 

 

 

 

上面只是引用关系，利用的是在<property>节点中的<value>属性或者是<value>节点中使用“ref”关键字进行bean之间的引用的。.在上面还有就是级联关系，就是说可以通过一些方法为引用中对象的相关属性的赋值。（比如上面的：<property name="book.price" value="34.4"></property>，但是注意的是，在进行这样的赋值时，以上面为例，也就是为book的price进行间接赋值时候，必须保证book所对应的类Books类是已经进行过初始化的，不然会出现错误，这是不同于struts2中的级联关系的。）

 

还有就是关于List集合属性的使用。

 

 

 

（四）、验证集合属性中的Map，properties。

 

代码：

 

POJO：

 


package qau.edu;

 

import java.util.Map;

import java.util.Properties;

 

publicclass CollectionDemo {

 

   private Map<String,Books> books ;

   private Properties pros ;

 

   public Map<String, Books> getBooks() {

      returnbooks;

   }

 

   publicvoid setBooks(Map<String, Books> books) {

      this.books = books;

   }

  

 

   public Properties getPros() {

      returnpros;

   }

 

   publicvoid setPros(Properties pros) {

      this.pros = pros;

   }

 

   @Override

   public String toString() {

      return"CollectionDemo [books=" + books + ", pros=" + pros + "]";

   }

 

  

  

  

}

 

 

测试类代码：

 


// 测试Map和properties集合 ；

  

   @Test

   publicvoid test7(){

     

//    创建applicationContext对象；

     

      ApplicationContext ctx2 = new ClassPathXmlApplicationContext("Ren.xml");

     

//    获取对象；

     

      CollectionDemo maps = (CollectionDemo)ctx2.getBean("map1");

     

//    输出打印结果；

     

      System.out.println(maps);

  }

 

执行结果：

 


十一月 21, 2014 11:14:10 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org[email protected]811e18: startup date [Fri Nov 21 23:14:10 CST 2014]; root of context hierarchy

十一月 21, 2014 11:14:10 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

信息: Loading XML bean definitions from class path resource [Ren.xml]

CollectionDemo [books={BB=Books [Number=10003, name=《平凡的世界》, price=34.4, page=23], AA=Books [Number=10004, name=《基督山伯爵》, price=0.0, page=24]}, pros={姓名=任建勇, 住址=青岛·八大关}]

 

 

 

 

（五）、util和P节点：

 

 

配置文件（部分）：


<!--演示util节点 -->

   

    <util:list id="utils">

   

      <ref bean="book1"/>

      <ref bean="book2"/>

   

    </util:list>

   

    <!-- 演示util和p节点（前提是导入这俩个节点） -->

   

    <bean id="per" class="qau.edu.Person" p:name="Renjianong" p:age="21">

 

     <property name="books">

        <ref bean="utils"/>

       

     </property>

   

    </bean>

 

 

测试类：

 


 

// 测试util节点和P节点；

  

  

   @Test

   publicvoid test8(){

     

//    创建applicationContext对象；

     

      ApplicationContext ctx2 = new ClassPathXmlApplicationContext("Ren.xml");

     

//    获取对象；

     

      Person person = (Person)ctx2.getBean("per");

     

//    输出打印结果；

     

      System.out.println(person);

   }

 

 

执行结果：

 

 


十一月 21, 2014 11:37:16 下午 org.springframework.context.support.AbstractApplicationContext prepareRefresh

信息: Refreshing org[email protected]b48230: startup date [Fri Nov 21 23:37:16 CST 2014]; root of context hierarchy

十一月 21, 2014 11:37:16 下午 org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions

信息: Loading XML bean definitions from class path resource [Ren.xml]

Person [name=Renjianong, age=21, books=[Books [Number=10003, name=《平凡的世界》, price=34.4, page=23], Books [Number=10004, name=《基督山伯爵》, price=0.0, page=24]]]

 

 

时间： 2024-10-09 16:33:03

Attempt-Spring-1：笔记的相关文章

Spring学习笔记（一）

Spring学习笔记(一) Spring核心思想: IOC:  Inversion Of Control (控制反转) / DI: Dependency Injection (依赖注入) AOP: Aspect Oriented Programming (面向切面编程) IOC 1. 简单的应用 Model package com.wangj.spring.model; public class User { private String username; private String pas

不错的Spring学习笔记(转)

Spring学习笔记(1)----简单的实例 ---------------------------------   首先需要准备Spring包,可从官方网站上下载.   下载解压后,必须的两个包是spring.jar和commons-logging.jar.此外为了便于测试加入了JUnit包.   在Myeclipse中创建Java项目.   编写一个接口类,为了简单,只加入了一个方法.   Java代码   1.package com.szy.spring.interfacebean;  

struts2，hibernate，spring整合笔记(2)

上一话struts2,hibernate,spring整合笔记(1) 接下来继续 配置完struts之后就要开始hibernate的配置 hibernate的环境并不依赖web开发环境,在我第一次配置hibernate时用的javase, 在window-> preferences->java->user libraries,创建一个新的Use libraries,添加相应的jar包 再在项目build path->build configurationpath->add l

struts2，hibernate，spring整合笔记(3)

struts2,hibernate,spring整合笔记(1) struts2,hibernate,spring整合笔记(2) 配好struts和hibernate就要开始spring了 老规矩,还是先导入jar包 spring.jar aspectjrt.jar aspectjwerver.jar cglib-nodep-2.1_3.jar common-logging.jar c3p0-0.9.1.jar 之后加入配置文件src目录下applicationContext.xml <?xml

《Spring学习笔记》：Spring、Hibernate、struts2的整合(以例子来慢慢讲解，篇幅较长)

<Spring学习笔记>:Spring.Hibernate.struts2的整合(以例子来慢慢讲解,篇幅较长) 最近在看马士兵老师的关于Spring方面的视频,讲解的挺好的,到了Spring.Hibernate.struts2整合这里,由于是以例子的形式来对Spring+Hibernate+struts2这3大框架进行整合,因此,自己还跟着写代码的过程中,发现还是遇到了很多问题,因此,就记录下. 特此说明:本篇博文完全参考于马士兵老师的<Spring视频教程>. 本篇博文均以如下这

spring学习笔记(19)mysql读写分离后端AOP控制实例

在这里,我们接上一篇文章,利用JNDI访问应用服务器配置的两个数据源来模拟同时操作不同的数据库如同时操作mysql和oracle等.实际上,上个例子可能用来模拟mysql数据库主从配置读写分离更贴切些.既然如此,在本例中,我们就完成读写分离的模拟在web端的配置实例. 续上次的例子,关于JNDI数据源的配置和spring datasource的配置这里不再重复.下面着重加入AOP实现DAO层动态分库调用.可先看上篇文章<spring学习笔记(18)使用JNDI模拟访问应用服务器多数据源实例 >

Spring学习笔记（三）

Spring学习笔记(三) AOP 一.使用Annotation方式实现AOP.步骤: xml里加入配置:<aop:aspectj-autoproxy /> <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org

Spring Security笔记：Remember Me(下次自动登录)

前一节学习了如何限制登录尝试次数,今天在这个基础上再增加一点新功能:Remember Me. 很多网站,比如博客园,在登录页面就有这个选项,勾选“下次自动登录”后,在一定时间段内,只要不清空浏览器Cookie,就可以自动登录. 一.spring-security.xml 最简单的配置 1 <http auto-config="true" use-expressions="true"> 2 ... 3 <remember-me /> 4 <

Spring学习笔记--initmethod和构造函数、setter方法的加载顺序

今天学习了一下spring中bean的初始化和销毁,突然想了解一下初始化方法跟构造函数及setter方法注入的执行顺序,记录在此,仅作为学习笔记. 当实例化一个bean时,可能需要执行一些初始化操作来确保该bean处于可用状态.同样地,当不再需要bean时,将其从容器中移除是,我们可以还需要按顺序 执行一些清除工作. package com.zp.chapter2; public class Auditorium { private String name; public void doBefo

Spring实战笔记2---Bean的装配

创建应用对象之间协作关系的行为通常成为装配,该篇的主要内容有两个,一个Spring装配Bean的几种方式以及Spring表达式,其实这两者是分不开的,在Spring中,对象无需自己负责查找或者创建与其关联的其他对象,相反容器负责把需要相互协作的对象一引用赋予各个对象,目前我们先说声明式的装配,注解式的装配等溜到下篇再详细记录,在声明用的xml配置文件中,可以使用表达式来完成一些简单的逻辑处理,和方法调用或者对象引用,在有些特殊的需求当中非它莫属,首先是装配Bean 声明Bean <bean id