几个Spring的小例子

一 .
第一个Spring程序：

首先创建一个接口：
package cn.itcast;

public interface GreetingService {
 public void sayGreeting();
}

创建一个实现上面接口的JavaBean，用get，set方法获取和设置变量greeting的值
package cn.itcast;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

public class GreetingServiceImp1 implements GreetingService {

 private String greeting;

 private Log log = LogFactory.getLog(GreetingServiceImp1.class);

 public void sayGreeting() {//实现接口中方法
  log.info("Hello ! " + greeting);
 }

 public String getGreeting() {
  return greeting;
 }

 public void setGreeting(String greeting) {
  this.greeting = greeting;
 }
}
接下来写一个XML文件：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans><!--所有的Spring的xml配置文件都是以beans为根元素-->
<!--bean元素的id属性为对象取一个名字，class属性则为完整的类名-->
 <bean id="greetingService" class="cn.itcast.GreetingServiceImp1">
  <property name="greeting"><!--用property元素为name为greeting赋值，-->
   <value>张三</value>
  </property>
 </bean>
</beans>

这个xml文件等价于下面这样的java代码：
cn.itcast.GreetingServiceImp1 greetingService = new cn.itcast.GreetingServiceImp1();
greetingService.setGreeting("张三");

下面这个类用于载入Spring容器获得一个GreetingService对象并调用此对象的方法打印出信息。
package cn.itcast;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.FileSystemResource;

public class FirstSpring {

 public static void main(String[] args) {
  try {
   BeanFactory factory = new XmlBeanFactory(new FileSystemResource(
     "classes/cn/itcast/hello.xml"));
   GreetingService greetingService = (GreetingService) factory.getBean("greetingService");
   greetingService.sayGreeting();
  } catch (BeansException e) {
   e.printStackTrace();
  }
 }
}

因为我们这里用到了Log4j，所以最好加上一个log4j的xml配置文件。
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">

<log4j:configuration debug="false" xmlns:log4j="http://jakarta.apache.org/log4j/">
 <appender name="systemout" class="org.apache.log4j.ConsoleAppender"><!--指定输出到控制台-->
  <layout class="org.apache.log4j.SimpleLayout"></layout><!--指定layout-->
 </appender>

 <root>
  <level value="info" />
  <appender-ref ref="systemout" />
 </root>
</log4j:configuration>

好了。一个世界上最简单的Spring程序编写完了。运行的结果毫无悬念的说一定是打印出下面这样的消息：
Hello ! 张三

二.
一个读取属性文件的小程序

首先建一个简单的property文件：collectionfile.property
class=java.util.ArrayList
elements=aaa,bbb,ccc

此类中有一个读取属性文件的方法。
package cn.itcast;

import java.io.IOException;
import java.io.InputStream;
import java.util.Collection;
import java.util.Properties;

public class PropertyReader {
 public static String KEY_CLASS = "class";
 public static String KEY_ELEMENTS = "elements";

 public static Collection getCollection() {
  InputStream ips = null;
  try {
   ips = SpringClass.class.getResourceAsStream(
     "/cn/itcast/collectionfile.property");//用getResourceAsStream获取给定名称的资源
  } catch (Exception e1){
   e1.printStackTrace();
  }
  if (ips == null) {
   throw new IllegalArgumentException("File not exists!");
  }

  Properties props = new Properties();
  try {
   props.load(ips);//从给定的输入流中读取属性列表（键和元素对）。
  } catch (IOException e) {
   e.printStackTrace();
  }

  String className = props.getProperty(KEY_CLASS);

  Collection collection = null;
  try {
   Class classCollection = Class.forName(className);
   collection = (Collection) classCollection.newInstance();

   String strElements = props.getProperty(KEY_ELEMENTS);
   String[] elements = strElements.split(",");

   for (String element : elements) {
    collection.add(element);
   }
  } catch (Exception e) {
   e.printStackTrace();
  }
  return collection;

 }

}

最后来测试一下上面的getCollection方法。
package cn.itcast;

import java.util.Collection;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.log4j.BasicConfigurator;

public class MainClass {
 public static void main(String[] args) {
  Log log = LogFactory.getLog(MainClass.class);
  BasicConfigurator.configure();
  Collection collection = PropertyReader.getCollection();
  for (Object obj : collection) {
   log.info(obj);
  }
 }
}

运行！打印出来了：
aaa
bbb
ccc

OK，把属性文件的内容改一下，加些中文：
class=java.util.ArrayList
elements=张三,李四
再运行，会看到下面的信息：
???
???

奇怪吧？这时就要用到一个native2ascii命令把属性文件转换才行了，用法如下：
native2ascii -encoding gb2312 collectionfile.property collectionfile1.property
然后会看到多了一个collectionfile1.property的文件，删掉collectionfile.property再把
collectionfile1.property改为collectionfile.property再运行就能看到正确的结果了:
张三
李四

三.
下面这个程序不用set方法复制，而只用构造方法的方式

先创建一个简单的JavaBean：
package cn.itcast;

public class HelloBean {
 private String helloWord = "hello";

 private String user = "NoBody";

 public HelloBean(String helloWord, String user) {
  this.helloWord = helloWord;
  this.user = user;
 }
 
 public String sayHelloToUser(){
  return helloWord + "!" + user + "!";
 }
}

再建一个xml配置文件：bean.xml
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

<!--初始化三个HelloBean，并用constructor-arg元素为构造方法传入值-->
 <bean id="helloBean1" class="cn.itcast.HelloBean">
  <constructor-arg index="0">
   <value>Hello</value>
  </constructor-arg>
  <constructor-arg index="1">
   <value>张三</value>
  </constructor-arg>
 </bean>

 <bean id="helloBean2" class="cn.itcast.HelloBean">
  <constructor-arg index="0">
   <value>Hello</value>
  </constructor-arg>
  <constructor-arg index="1">
   <value>李四</value>
  </constructor-arg>
 </bean>

 <bean id="helloBean3" class="cn.itcast.HelloBean">
  <constructor-arg index="0">
   <value>Hello</value>
  </constructor-arg>
  <constructor-arg index="1">
   <value>王五</value>
  </constructor-arg>
 </bean>

</beans>

下面的类读取属性文件的内容
package cn.itcast;

import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.ListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class MainClass {
 static final Logger log = Logger.getLogger(MainClass.class);

 public static void main(String[] args) {

  Resource resource = new ClassPathResource("bean.xml");
  ListableBeanFactory factory = new XmlBeanFactory(resource);
  //ListableBeanFactory接口用于接收多个bean

  Map map = factory.getBeansOfType(HelloBean.class);
  //取出类型为HelloBean的bean集合，返回结果为一个键值对，键为对象名，也就是xml文件的bean元素的
  //id属性的值，值为class属性的值。
  Set set = map.keySet();//Map的键是一个Set集合
  Iterator it = set.iterator();

  while (it.hasNext()) {//循环取出键和值
   Object obj = it.next();
   HelloBean hello = (HelloBean) factory.getBean(obj.toString());
   log.info(hello.sayHelloToUser());
  }
 }
}

运行结果：
Hello!张三!
Hello!李四!
Hello!王五!

四.

为属性设置值：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="someBean" class="cn.itcast.SomeBean">
  <property name="list"><!--属性类型为List的-->
   <list>
    <value>张三</value>
    <value>李四</value>
    <value>王五</value>
   </list>
  </property>

  <property name="map"><!--属性类型为Map的-->
   <map>
    <entry key="1">
     <value>aaaa</value>
    </entry>
    <entry key="2">
     <value>bbbb</value>
    </entry>
    <entry key="3">
     <value>cccc</value>
    </entry>
    <entry key="4">
     <value>dddd</value>
    </entry>
   </map>
  </property>

  <property name="strings"><!--属性类型为数组的-->
   <list>
    <value>11111111</value>
    <value>22222222</value>
    <value>33333333</value>
    <value>44444444</value>
   </list>
  </property>

  <property name="props"><!--属性类型为Properties的-->
   <props>
    <prop key="1">001</prop>
    <prop key="2">002</prop>
    <prop key="3">003</prop>
    <prop key="4">004</prop>
   </props>
  </property>
  
  <property name="set"><!--属性类型为Set的-->
   <set>
    <value>11111111</value>
    <value>22222222</value>
    <value>33333333</value>
    <value>44444444</value>
   </set>
  </property>

 </bean>
</beans>

五.
当配置文件为properties文件时，比如文件名为hello.properties：
helloBean.class=cn.itcast.HelloBean
helloBean.helloWord=Hello,World
helloBean.user=zhangsan

JavaBean：

package cn.itcast;

public class HelloBean {
 private String helloWord = "hello";

 private String user = "NoBody";

  public String getHelloWord() {
  return helloWord;
 }

 public void setHelloWord(String helloWord) {
  this.helloWord = helloWord;
 }

 public String getUser() {
  return user;
 }

 public void setUser(String user) {
  this.user = user;
 }
 
 public String sayHelloToUser(){
  return helloWord + "!" + user + "!";
 }
}

来写个主函数看看效果
package cn.itcast;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.PropertiesBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;

public class MainClass {
 public static void main(String[] args) {
  BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
  PropertiesBeanDefinitionReader reader = new PropertiesBeanDefinitionReader(reg);
  reader.loadBeanDefinitions(new ClassPathResource("hello.properties"));
  BeanFactory factory = (BeanFactory)reg;
  HelloBean hello = (HelloBean)factory.getBean("helloBean");
  Logger log = Logger.getLogger(MainClass.class);
  log.info(hello.sayHelloToUser());
 }
}

运行结果：
Hello,World!zhangsan!

六.
下面是一个代理的spring程序
首先来创建一个实现了FactoryBean接口的Bean：
package cn.itcast;

import java.lang.reflect.Proxy;
import org.springframework.beans.factory.FactoryBean;
public class MyFactoryBean implements FactoryBean {
 private String target = null;
 private String myInterface = null;
 public Object getObject() throws Exception {
  Class[] clazzes = new Class[] { Class.forName(myInterface) };
  Class clazz = Class.forName(target);
  Object objTarget = clazz.newInstance();
  Object objProxy = Proxy.newProxyInstance(this.getClass()
    .getClassLoader(), clazzes, new MyInvocationHandler(objTarget));
  return objProxy;
 }

 public Class getObjectType() {
  return null;
 }

 public boolean isSingleton() {
  return false;
 }

 public String getTarget() {
  return target;
 }

 public void setTarget(String target) {
  this.target = target;
 }

 public String getMyInterface() {
  return myInterface;
 }

 public void setMyInterface(String myInterface) {
  this.myInterface = myInterface;
 }

}

再建一个xml文件为上面的Bean里面的属性赋值：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
 <bean id="myfactorybean" class="cn.itcast.MyFactoryBean">
  <property name="target">
   <value>java.util.Vector</value>
  </property>
  <property name="myInterface">
   <value>java.util.Collection</value>
  </property>
 </bean>
</beans>

再来创建一个代理类：
package cn.itcast;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import org.apache.commons.logging.LogFactory;

public class MyInvocationHandler implements InvocationHandler {
 private Object objTarget = null;
 public MyInvocationHandler(Object objTarget) {
  super();
  this.objTarget = objTarget;
 }

 public Object invoke(Object proxy, Method method, Object[] args)
   throws Throwable {
  LogFactory.getLog(this.getClass()).info(method.getName() + " is calling!");
  //在外面每次调用method方法时都会记录日志信息，这就是代理的好处，当然你还可以加入其他的一些
  //业务逻辑的代码。
  Object objValue = method.invoke(objTarget,args);
  return objValue;
  //千万要注意：
  //这里objValue的类型可谓是关系重大，在后面调用objTarget的method方法时返回值的类型会和
  //这个objValue的类型相比较，如果不一样就会跑出空指针异常，
 }

}

//下面来测试一下
package cn.itcast;

import java.util.Collection;

import org.apache.log4j.BasicConfigurator;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;

public class MainClass {
 public static void main(String[] args) {
  BeanFactory factory = new XmlBeanFactory(new ClassPathResource("/applicationContext.xml"));
  Object obj = factory.getBean("myfactorybean");
  BasicConfigurator.configure();
  ((Collection)obj).add(new String("abc"));
 }
}

运行结果：
cn.itcast.MyInvocationHandler  - add is calling!

从结果我们可以发现，MyFactoryBean里面没有任何打印或者记录日志的代码，但是运行时输出的信息从哪来的呢，就是从代理类那边打印出来的。是这样的，如果一个javaBean没有实现FactoryBean接口时，我们调用
getBean方法返回的就是这个javaBean本身的一个对象了，否则就是返回这个javaBean重写FactoryBean的
getObject()时返回的那个Object，在这里，我们在这个方法里面就是把业务交给另一个代理类
MyInvocationHandler去做了。这个程序可谓是”代代理“了。  :)