一 .
第一个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去做了。这个程序可谓是”代代理“了。 :)