BlogJava-小小程序员-随笔分类-『Spring 』

图解spring mvc

~小Q — Thu, 15 Jun 2006 14:44:00 GMT

注解：
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端

~小Q 2006-06-15 22:44 发表评论

Quartz的cron表达式

~小Q — Wed, 14 Jun 2006 09:36:00 GMT

摘要: 介绍Quartz的cron表达式阅读全文

~小Q 2006-06-14 17:36 发表评论

在spring利用javamail，quartz定时发送邮件

~小Q — Tue, 13 Jun 2006 14:06:00 GMT

在web开发中，我们经常需要定时完成一些功能。比如定义统计报表啊，统计用户排名等等。利用spring就可以轻松地做到这些任务。下面我就以定时发送邮件来来展示如何利用spring定时发送邮件，以及spring对JavaMail的简化。
MailService.java类

package com.open.quartz;
import org.springframework.mail.MailException;
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;
public class MailService {
    private MailSender mailSender;
    private SimpleMailMessage mailMessage;//邮件模板
    public void sendMail() {
        System.out.println("-----------发送邮件!---------");
        SimpleMailMessage msg=new SimpleMailMessage(this.mailMessage);
        msg.setText("this is a test mail");
        try {
            mailSender.send(msg);
        } catch (MailException e) {
            e.printStackTrace();
        }
        System.out.println("-----------发送成功!---------");
    }
     //省略set,get方法
}

在web.xml里添加以下代码

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

在WEB-INF目录下添加applicationContext.xml文件

<beans>
    <bean id="mailSender"
        class="org.springframework.mail.javamail.JavaMailSenderImpl">
        <property name="host" value="smtp.163.com"/>

        <property name="username" value="填入用户名"/>
        <property name="password" value="填入密码"/>
        <property name="javaMailProperties">
            <props>
                <prop key="mail.smtp.auth">trueprop>
            props>
        property>
    bean>

    <bean id="mailMessage" class="org.springframework.mail.SimpleMailMessage">
        <property name="to" value="asm_c_yuan@163.com"/>
        <property name="from" value="asm_c_yuan@163.com"/>
        <property name="subject" value="test"/>
    bean>
        <bean id="ms" class="com.open.quartz.MailService" autowire="byName"/>
    <bean id="reportJob"
        class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
        <property name="targetObject" ref="ms"/>
        <property name="targetMethod" value="sendMail"/>
    bean>

    <bean id="simpleTrigger"
        class="org.springframework.scheduling.quartz.SimpleTriggerBean">
        <property name="jobDetail" ref="reportJob"/>
        <property name="startDelay" value="1"/>   在web启动多少毫秒后启动任务
        <property name="repeatInterval" value="100000000"/> 表示没隔多少毫秒启动
    bean>

    <bean id="cronTrigger"
        class="org.springframework.scheduling.quartz.CronTriggerBean">
        <property name="jobDetail" ref="reportJob"/>
        <property name="cronExpression" value="0 0 6 * * ?"/> 指明每天早上6点启动任务,表达式的解释见下篇文章
    bean>
    <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
        <property name="triggers">
            <list>
                <ref bean="simpleTrigger"/>
            list>
        property>
    bean>
bean>

涉及的jar包有:spring.jar,javamail.jar,activation.jar,quartz.jar

~小Q 2006-06-13 22:06 发表评论

spring对java远程调用的简化(三)之HTTPinvoker

~小Q — Tue, 13 Jun 2006 06:02:00 GMT

RMI使用Java标准的对象序列化，但很难穿越防火墙；另一方面，Hessian、Burlap能很好地穿越防火墙，但使用自己私有的一套对象序列化机制，当数据模型非常复杂的话，就不好了。spring的Httpinvoker是基于Http的远程调用，并且使用Java的序列化机制。它的缺点就是，服务端的应用必须基于spring。除了java，还不能移植到其他语言上。
spring的用法跟hessian,burlap一样。把代理类，和服务输出类分别改成
org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean
org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter
就可以了，不用改代码就可以运行第二节的例子

~小Q 2006-06-13 14:02 发表评论

spring对java远程调用的简化(二)之Hessian,Burlap

~小Q — Tue, 13 Jun 2006 05:19:00 GMT

Hessian,Burlap是Caucho提供的两种基于Http的轻量级远程服务。
Hessian像RMI那样，使用二进制消息来建立客户端和服务端之间的交流。与其他二进制远程技术(想RMI)不同的是，它可以移植到其他非Java的语言。
Burlap是一种基于Xml的远程技术，这使得他可以移植到任何可以解析XML的语言中。比起Hessian，它的可读性更强。和其他基于Xml的远程技术（如SOAP和XML-RPC）不同，它的消息结构尽可能简单，不需要额外的外部定义语言(如WSDL或IDL).
针对前面的例子，看看spring对Hessian和Burlap是怎么简化。
1.Hessian
1)客户端的配置，只需要修改bean_client.xml的配置

<beans>

    <bean id="pf" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">
        <property name="serviceUrl" value="http://192.168.1.8:8080/spring/pay.service"/>
        <property name="serviceInterface" value="com.open.rmi.ex2.PerfectTimeI"/>
    bean>
    <bean id="test" class="com.open.rmi.ex2.DisplayPerfectTime">
        <property name="pf" ref="pf"/>
    bean>
beans>

Hessian和Burlap是基于Http的,http://192.168.1.8:8080/spring/pay.service是服务端的访问地址
2)服务端的配置，这里采用spring的mvc
先在web.xml中增加下面的配置

<servlet>
        <servlet-name>Dispatcherservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
servlet>
    <servlet-mapping>
        <servlet-name>Dispatcherservlet-name>
        <url-pattern>*.serviceurl-pattern>
    servlet-mapping>

第一节中的bean_server.xml就改配置Dispatcher-servlet.xml文件中了

<beans>
    <bean id="urlMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
        <property name="mappings">
            <props>
                <prop key="/pay.service">hessianServiceprop>
            props>
        property>
    bean>
    <bean id="hessianService" class="org.springframework.remoting.caucho.HessianServiceExporter">
        <property name="service" ref="pt"/>
        <property name="serviceInterface" value="com.open.rmi.ex2.PerfectTimeI"/>
    bean>
    <bean id="pt" class="com.open.rmi.ex2.PerfectTime"/>
bean>

跟第一节的相比只是更换了代理类，启动tomcat，在运行TestClient就可以看到输出结果了
2.Burlap
只要把bean_client.xml中的HessianProxyFactoryBean改成BurlapProxyFactoryBean,Dispatcher-servlet.xml中的HessianServiceExporter改成BurlapServiceExporter，就可以了。
通过上面可以看到，应用从纯RMI转换到Hessian,Burlap是多么容易啊!

~小Q 2006-06-13 13:19 发表评论

spring对java远程调用的简化(一)之RMI

~小Q — Mon, 12 Jun 2006 15:15:00 GMT

Java开发者可以利用的远程技术有以下几种:
1.远程方法调用（RMI）
2.Caucho的Hessian和Burlap
3.Spring自己的HTTP invoker
4.EJB
5.Web Services
一.RMI
它由5个包及3个应用工具组成
java.rmi 组织客户端的RMI类、接口和异常
java.rmi.server 组织服务器端的RMI类接口和异常
java.rmi.registry 组织用于管理RMI命名服务的类
java.rmi.dgc 组织用于管理分布式垃圾收集的类
java.rmi.activation 组织用于实现按需激活的RMI服务的类
rmic 编译器，它产生RMI使用的存根和框架以完成分布式通信
rmiregistry 一个为RMI提供命名服务的服务器，这项服务把名字和对象关联在一起
rmid 一个支持RMI激活框架的服务器

     如果具体还不知道什么是RMI，可以参考这篇非常不错的文章《JavaRMI入门实战》
注意:
    1)要把PerfectTime 和PerfectTimeI类中的
   System.setSecurityManager(new RMISecurityManager()); 注释掉（因为这需要配安全策略，比较麻烦）
   2)还有在JDK5下，用rmic -d命令的话只会输出一个文件，因为JDK5对RMI进行了优化
接下来看看用spring对《JavaRMI入门实战》例子的简化
1.客户端的配置及代码
PerfectTimeI接口（不用继承java.rmi.Remote接口了，普通的POJO）

package com.open.rmi.ex2;
public interface PerfectTimeI {
long getPerfectTime();
}

DisplayPerfectTime类(也是一个普通的类)

package com.open.rmi.ex2;
public class DisplayPerfectTime {
    private PerfectTimeI pf;
    public void display() {
        for (int i = 0; i < 10; i++) {
            System.out.println("PerfectTime:" + pf.getPerfectTime());
        }
    }
    //省略了pf的get,set方法
}

客户端配置bean_client.xml

<beans>

    <bean id="pf" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
        <property name="serviceUrl" value="rmi://192.168.1.8:1099/perfect_time"/>
        <property name="serviceInterface" value="com.open.rmi.ex2.PerfectTimeI"/>
    bean>
    <bean id="test" class="com.open.rmi.ex2.DisplayPerfectTime">
        <property name="pf" ref="pf"/>
    bean>
beans>

2.服务端的配置及代码
PerfectTime类(爽吧，简简单单的POJO)

package com.open.rmi.ex2;
public class PerfectTime  implements PerfectTimeI {
    public long getPerfectTime() {
        return System.currentTimeMillis();
    }
}

配置bean_server.xml

<beans>

    <bean id="serviceExporter"
        class="org.springframework.remoting.rmi.RmiServiceExporter">
        <property name="service" ref="pt"/>
        <property name="serviceName" value="perfect_time"/>
        <property name="serviceInterface" value="com.open.rmi.ex2.PerfectTimeI"/>
    bean>
    <bean id="pt" class="com.open.rmi.ex2.PerfectTime"/>
beans>

3.测试代码
TestServer.java

package com.open.rmi.ex2;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestServer {
    public static void main(String[] args) {
        BeanFactory bf=new ClassPathXmlApplicationContext("bean_server.xml");
        bf.getBean("serviceExporter");
    }
}

TestClient.java

package com.open.rmi.ex2;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestClient {
    public static void main(String[] args) {
        BeanFactory bf = new ClassPathXmlApplicationContext("bean_client.xml");
        DisplayPerfectTime test = (DisplayPerfectTime)bf.getBean("test");
        test.display();
    }
}

先运行TestServer，输出

RmiServiceExporter - Could not detect RMI registry - creating new one

在运行TestClient就可以看到结果了

PerfectTime:1150125107468
PerfectTime:1150125107484
PerfectTime:1150125107484

看到没，你根本不用运行rmic -d G:\RMI test.PerfectTime，start rmiregistry 。
这就是spring的魅力啊

~小Q 2006-06-12 23:15 发表评论

spring中事务的属性

~小Q — Sun, 11 Jun 2006 14:50:00 GMT

1.传播行为
定义了关于客户端和被调用方法的事务边界。传播规则就是在说明新的事务是否要被启动或是挂起，或者方法是否要在事务环境中运行。
spring定义了7种不同的传播行为。
1)PROPAGATION_MANDATORY
表明方法必须要在事务中运行。如果事务不存在，抛出异常
2)PROPAGATION_NESTED
表示如果当前已经存在一个事务，则该方法应当运行在一个嵌套的事务中。被嵌套的事务可以从当前事务中单独地提交或回滚。如果当前事务不存在，就相当于PROPAGATION_REQUIRED
3)PROPAGATION_NEVER
表示当前的方法不应该运行在一个事务上下文中。如果当前存在一个事务，则会抛出一个异常。
4)PROPAGATION_NOT_SUPPORTED
表示该方法不应该在事务中运行。如果一个现有的事务正在运行中。它将在该方法的运行期间被挂起
5)PROPAGATION_REQUIRED
表示当前方法必须运行在一个事务中。如果一个现有的事务正在运行中，该方法将运行在这个事务中。否则的话，就要开始一个新的事务。
6)PROPAGATION_REQUIRES_NEW
表示当前方法必须运行在它自己的事务中。如果一个现有事务在运行的话，将在这个方法运行期间被挂起。
7)PROPAGATION_SUPPORTS
表示当前方法不需要事务处理环境，但如果有一个事务已经在运行的话，这个方法也可以在这个事务中运行
2.隔离级别
多个事务并发运行的关系。因为并发会导致以下问题
.脏读(Dirty read) 一个事务读取了被另一个事务改写但还没提交的数据。
.不可重复读(Nonrepeatable read) 一个事务执行相同的查询两次或两次以上，但每次查询结果都不同时。这由于另一个并发事务在两次查询之间更新了数据
.幻读(Phantom read)
当一个事务读取几行记录后，另一个并发事务插入一些记录，就发生了幻读
spring定义了以下5种隔离关系
1)ISOLATION_DEFAULT
使用后端数据库默认得隔离级别
2)ISOLATION_READ_UNCOMMITTED
允许你读取还未提交的改变了的数据。可能导致脏读，不可重复读，幻读
3)ISOLATION_READ_COMMITTTED
运行在并发事务已经提价后读取。可防止脏读，但不可重复读，幻读都有可能发生
4)ISOLATION_REPEATABLE_READ
对相同字段的多次读取结果是一致的，除非数据被事务本身。可防止脏读，不可重复读，但幻读仍可能发生。
5)ISOLATION_SERIALIZABLE
完全服从ACID的隔离级别，确保不发生脏读，不可重复读，幻读。它的典型做法就是完全锁定在事务中涉及的数据表。因此它是最慢地。
3.只读提示
通过只读属性，数据库可以对事务进行优化。
4.事务超时时间
设置了的话，事务在超过这个时间后就自动回滚。避免占用资源过久。

~小Q 2006-06-11 22:50 发表评论

事务的特点以及spring提供事务管理器的简介

~小Q — Sat, 10 Jun 2006 06:02:00 GMT

事务的特点(ACID)
1)原子性(Atomic)
事务由一个或多个行为绑在一起组成的，好像一个单独的工作单元。事务中的操作要么都发生，要么都不发生。
2)一致性(Consistent)一旦一个事务结束了(不管成功与否)，系统所处的状态和它的业务规则是一致的。
3)隔离性(Isolated)事务应该允许多个用户操作同一个数据，一个用户的操作不会和其他用户的操作相混浊。
4)持久性(Durable)一旦事务完成，事务的结果应该持久化。

spring提供了以下事务管理器
1)DataSourceTransactionManager 在单一的JDBC DataSource中管理事务
2)HibernateTransactionManager 当持久化机制是Hibernate时，用它来管理事务
3)JdoTransactionManager 当持久化机制时JDO时，用它来管理事务
4)JtaTransactionManager使用一个JTA实行来管理事务。当一个事务跨越多个资源时必须使用
5)PersistenceBrokerTransactionManager当Apache的OJB用作持久化时，用它来管理事务
6)TopLinkTransactionManager当oracle的TopLink用作持久化时，用它来管理事务
7)JmsTransactionManager用它来管理JMS的事务

~小Q 2006-06-10 14:02 发表评论

ProxyFactoryBean属性介绍

~小Q — Sat, 10 Jun 2006 03:15:00 GMT

今天在看spring in action 的AOP,就把它抄录下来
target:代理的目标类
proxyInterfaces:代理类应该实现的接口列表
interceptorNames:需要应用到目标对象上的通知Bean的名字.可以是拦截器,advisor和其他通知类型的名字。这个属性必须按照在BeanFactory中的顺序设置
singleton:
aopProxyFactory:使用的ProxyFactoryBean实现。Spring带有两种实现(JDK动态代理和CGLIB)。通常不需要使用这个属性
exposeProxy:目标对象是否需要得到当前的代理。通过调用AopContext.getCurrentProxy实现。
frozen:一旦工厂被创建，是否可以修改代理的通知。当设置为true时，在运行时就不能修改ProxyFactoryBean了。通常不需要使用这个属性。
optimize：是否对创建的代理进行优化(只适用于CGLIB)
ProxyTargetClass：是否代理目标类，而不是实现接口。只能在使用CGLIB时使用

~小Q 2006-06-10 11:15 发表评论

spring中基础核心接口介绍

~小Q — Fri, 09 Jun 2006 03:56:00 GMT

spring中基础核心接口总结
理解这几个接口，及其实现类就可以快速了解spring,具体的用法参考其他spring资料

1.BeanFactory最基础最核心的接口
重要的实现类有：
XmlBeanFactory,以及ApplicationContext接口下的类

2.Resource接口,可以通用地访问文件资源
1)ClassPathResource:读取得形式为"classpath:ApplicationContext.xml"
2)FileStstemResource:读取得形式为"file:c:\spring\src\ApplicationContext.xml"
3)ServletContextResource:读取得形式为"WEB-INF\ApplicationContext.xml"
//ResourceLoader类用于载入Resource

3.FactoryBean工厂bean
它本身在bean factory中定义，同时又是用于创建目标bean的工厂
spring有以下实现:
1)JndiObjectFactoryBean:通过JNDI查找获取对象
2)LocalSessionFactoryBean:用于在本地装配Hibernate SessionFactory
3)LocalSessionFactoryBean:用于在本地装配JDO PersistenceManagerFactory
4)ProxyFactoryBean:用于获取AOP的代理
5)TransactionProxyFactoryBean:用于为对象创建事务代理，用于实现简捷易用的声明性事务代理
6)RmiProxyFactoryBean:为通过RMI访问的远程对象创建一个代理

4.ApplicationContext加强了BeanFactory的功能，支持以下功能
1)国际化支持
2)资源访问
3)事件监听机制
它的重要的实现类有：
FileSystemXmlApplicationContext,ClassPathXmlApplication,XmlWebApplicationContext

5.Bean生命周期的回调接口
BeanFactoryPostProcessor,InitializingBean,DisposableBean,BeanFactoryAware,ApplicationContextAware,ResourceLoader,BeanPostProcessor

6.MessageSource接口
它的实现类有ResourceBundleMessageSource,ReloadableResourceBundleMessageSource.后者在属性文件修改后会重新载入

暂时介绍这几个

~小Q 2006-06-09 11:56 发表评论

最简单的动态代理实例(spring基于接口代理的AOP原理)

~小Q — Fri, 09 Jun 2006 02:20:00 GMT

JDK的动态代理是基于接口的

package com.open.aop;
public interface BusinessInterface {
public void processBusiness();
}

目标对象

package com.open.aop;
public class BusinessObject implements BusinessInterface {
    public void processBusiness() {
        System.out.println("action");
    }
}

代理对象

package com.open.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class LogHandler implements InvocationHandler {
    private Object delegate;
    public Object binder(Object delegate) {
        this.delegate=delegate;
        return Proxy.newProxyInstance(delegate.getClass().getClassLoader(),
                delegate.getClass().getInterfaces(),this);
    }
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        Object obj = null;
        System.out.println("对象方法调用前");
        try {
            obj = method.invoke(delegate, args);
        } catch (Exception e) {
        }
        System.out.println("对象方法调用后");
        return obj;
    }
}

测试类

package com.open.aop;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Test {
    public static void main(String[] args) {
        BusinessInterface bi = (BusinessInterface) new LogHandler()
                .binder(new BusinessObject());
        bi.processBusiness();
    }
}

输出结果

对象方法调用前
action
对象方法调用后

~小Q 2006-06-09 10:20 发表评论

spring复杂属性的配置

~小Q — Thu, 08 Jun 2006 04:48:00 GMT

package com.open.bean;
import java.util.List;
import java.util.Map;
import java.util.Properties;
public class BeanSet {
     private String[] str1;
     private String[] str2;
     private List lst;
     private Map map;
     private Properties props;
     private ChildBean[] child;
    // 省略set,get方法
}

package com.open.bean;
public class ChildBean {}

配置文件

<beans>
<bean id="bs" class="com.open.bean.BeanSet">
        <property name="str1">
            <list>
                <value>value1value>
                <value>value2value>
            list>
        property>
        <property name="str2">
            <value>value3,value4value>
        property>
        <property name="lst">
            <list>
                <value>value5value>
                <ref bean="cc1"/>
            list>
        property>
        <property name="map">
            <map>
                <entry key="key1">
                    <value>xxxvalue>
                entry>
                <entry key="key2">
                    <ref bean="cc1"/>
                entry>
            map>
        property>
        <property name="props">
            <props>
                <prop key="key1">xxxprop>
                <prop key="key2">yyyprop>
            props>
        property>
        <property name="child">
            <list>
                <ref bean="cc1"/>
                <ref bean="cc2"/>
            list>
        property>
    bean>
    <bean id="cc1" class="com.open.bean.ChildBean"/>
    <bean id="cc2" class="com.open.bean.ChildBean"/>
beans>

测试代码

package com.open.bean;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test1 {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext cx=
            new ClassPathXmlApplicationContext("bean.xml");
        BeanSet bs=(BeanSet)cx.getBean("bs");
        String[] str1=bs.getStr1();
        String[] str2=bs.getStr1();
        List lst=bs.getLst();
        Map map=bs.getMap();
        Properties props=bs.getProps();
        ChildBean[] cb=bs.getChild();
        System.out.println("str1="+"["+str1[0]+","+str1[1]+"]");
        System.out.println("str2="+"["+str2[0]+","+str2[1]+"]");
        System.out.println("lst="+lst);
        System.out.println("map="+map);
        System.out.println("props="+props);
        System.out.println("cb="+"["+cb[0]+","+cb[1]+"]");
    }
}

输出结果

str1=[value1,value2]
str2=[value1,value2]
lst=[value5, com.open.bean.ChildBean@1df073d]
map={key1=xxx, key2=com.open.bean.ChildBean@1df073d}
props={key2=yyy, key1=xxx}
cb=[com.open.bean.ChildBean@1df073d,com.open.bean.ChildBean@1546e25]

~小Q 2006-06-08 12:48 发表评论

Spring加载多个配置文件

~小Q — Wed, 07 Jun 2006 03:13:00 GMT

对于ApplicationContext

ApplicationContext act=new ClassPathXmlApplicationContext(new String[] {"bean1.xml","bean2.xml"});

对于BeanFactory

BeanDefinitionRegistry reg = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(reg);
reader.loadBeanDefinitions(new ClassPathResource("bean1.xml"));
reader.loadBeanDefinitions(new ClassPathResource("bean2.xml"));
BeanFactory bf=(BeanFactory)reg;

~小Q 2006-06-07 11:13 发表评论

spring如何引用properties文件里的配置

~小Q — Tue, 06 Jun 2006 18:40:00 GMT

1.PropertyPlaceholderConfigurer类
它是把属性中的定义的变量(var)替代,spring的配置文件中使用${var}的占位符

<beans>
<bean id="configBean" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
           <property name="location"><value>db.propertiesvalue>property>
bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName"><value>${jdbc.driverClassName}value>property>
    <property name="url"><value>${jdbc.url}value>property>
    <property name="username"><value>${jdbc.username}value>property>
    <property name="password"><value>${jdbc.password}value>property>
bean>
beans>

db.properties文件

jdbc.driverClassName=org.hsqldb.jdbcDriver
jdbc.url=jdbc:hsqldb:hsql://production:9002
jdbc.username=sa
jdbc.password=root

2.PropertyOverrideConfigurer类
跟PropertyPlaceholderConfigurer功能一样，不过用法不一样.不用占位符，在属性文件中
直接定义属性的值，这样就允许有默认值

<beans>
<bean id="configBean" class="org.springframework.beans.factory.config.PropertyOverrideConfigurer">
           <property name="location"><value>db.propertiesvalue>property>
bean>
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
    <property name="driverClassName"><value>org.hsqldb.jdbcDrivervalue>property>
    <property name="url"><value>jdbc:hsqldb:hsql://production:9002value>property>
    <property name="username"><value>testvalue>property>
    <property name="password"><value>123456value>property>
bean>
beans>

db.properties文件

dataSource.username=admin
dataSource.password=9527

在bean实例时，admin,9527将替代test,123456
3其他
1)如果需要引用多个属性，将configBean属性改为

<property name="locations">
<list>
<value>db.propertiesvalue>
<value>db1.propertiesvalue>
list>
property>

2)在ApplactionContext中是自动调用BeanFactoryPostProcessor接口的，如果要在BeanFactory中使用，必须手动添加:

XmlBeanFactory factory = new XmlBeanFactory(new FileSystemResource("beans.xml"));
PropertyPlaceholderConfigurer cfg = new PropertyPlaceholderConfigurer();
cfg.setLocation(new FileSystemResource("jdbc.properties"));
cfg.postProcessBeanFactory(factory);

~小Q 2006-06-07 02:40 发表评论

spring中自定义属性编辑器

~小Q — Tue, 06 Jun 2006 13:48:00 GMT

作用:spring利用属性编辑器,可以将字符串转化为相应的对象,然后注入到其他对象中.
例子:
Person类

package com.open.bean;
public class Person {
PhoneNumber phoneNumber;
//set,get方法省略
}

PhoneNumber类

package com.open.bean;
public class PhoneNumber {
    private String areaCode;
    private String number;
    public PhoneNumber(String areaCode,String number ) {
        this.areaCode=areaCode;
        this.number=number;
    }
    //set,get方法省略
}

自定义属性器PhoneEditor

package com.open.bean;
import java.beans.PropertyEditorSupport;
public class PhoneEditor extends PropertyEditorSupport {
    public void setAsText(String textValue) throws IllegalArgumentException {
        String []str=textValue.split("-");
        if(str!=null&&str.length==2) {
            PhoneNumber pn=new PhoneNumber(str[0],str[1]);
            setValue(pn);
        }else {
            setValue(new PhoneNumber("0000","0000000"));
        }
    }
}

利用PhoneEdior，在xml文件中就可以这么配置Person类了

<beans>
    <bean id="customEditorConfigurer"
        class="org.springframework.beans.factory.config.CustomEditorConfigurer">
        <property name="customEditors">
            <map>
                <entry key="com.open.bean.PhoneNumber">
                    <bean id="phoneEditor" class="com.open.bean.PhoneEditor"/>
                entry>
            map>
        property>
    bean>
    <bean id="person" class="com.open.bean.Person">
        <property name="phoneNumber" value="0731-8888888"/>
    bean>
beans>

spring默认提供以下属性编辑器，不用注册
ClassEditor 使用包含全称名的字符串设置java.lang.Class属性
CustomDateEditor 使用某种java.text.DateFormat对象将一个字符串设置给java.util.Date属性
FileEditor 使用包含文件路径的字符串设置java.io.File属性
LocalEditor 设置java.util.Local属性
StringArrayPropertyEditor 将一个包含逗号的String转化成String数组
StringTrimmerEditor 自动修正字符串属性，可以选择将空字符转变成null

~小Q 2006-06-06 21:48 发表评论

spring中Bean的生命周期

~小Q — Tue, 06 Jun 2006 11:56:00 GMT

先贴代码：
Life类

package com.open.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;
public class Life implements BeanFactoryAware, BeanNameAware,
        InitializingBean, DisposableBean {
    private String msg;
    public Life() {
        System.out.println("msg="+msg);
        System.out.println("构造函数");
    }
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("setBeanFactory");
    }
    public void setBeanName(String name) {
        System.out.println("setBeanName");
    }
    public void init() {
        System.out.println("初始化");
    }
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization");
        return null;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInitialization");
        return null;
    }
    public void afterPropertiesSet() throws Exception {
        System.out.println("afterPropertiesSet");
    }
    public void destroy() throws Exception {
        System.out.println("destroy");
    }
    public String getMsg() {
        return msg;
    }
    public void setMsg(String msg) {
        this.msg = msg;
    }
}

BeanPostProcessorImp类

package com.open.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;
public class BeanPostProcessorImp implements BeanPostProcessor {
    public Object postProcessBeforeInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessBeforeInitialization");
        return bean;
    }
    public Object postProcessAfterInitialization(Object bean, String beanName)
            throws BeansException {
        System.out.println("postProcessAfterInitialization");
        return bean;
    }
}

BeanCounter类

package com.open.bean;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
public class BeanCounter implements BeanFactoryPostProcessor {
    public void postProcessBeanFactory(
            ConfigurableListableBeanFactory beanFactory) throws BeansException {
        System.out.println("类的数量＝"+beanFactory.getBeanDefinitionCount());
    }
}

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>
    <bean id="life" name="life_name" class="com.open.bean.Life"
        init-method="init">
        <property name="msg" value="lifexxxx"/>
    bean>
    <bean id="processor" class="com.open.bean.BeanPostProcessorImp"/>
    <bean id="counter" class="com.open.bean.BeanCounter"/>
beans>

测试类

package com.open.bean;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class Test {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext cx=
            new ClassPathXmlApplicationContext("bean.xml");
         Life life=(Life)cx.getBean("life");
    }
}

输出结果

类的数量＝3
msg=null
构造函数
setBeanName
setBeanFactory
postProcessBeforeInitialization
afterPropertiesSet
初始化
postProcessAfterInitialization

解释：
调用BeanFactoryPostProcessor接口的postProcessBeanFactory方法
-->实例化,调用构造函数-->设置属性值
-->调用BeanNameAware的setBeanName()方法
-->调用BeanFactoryAware接口的setBeanFactory
-->调用BeanPostProcessor接口的postProcessBeforeInitialization()
-->调用InitializingBean接口的afterPropertiesSet()
-->调用bean.xml中制定的init-method指定init()方法
-->调用BeanPostProcessor接口的postProcessAfterInitialization()
容器关闭
-->DisposableBean接口的destroy()
-->调用bean.xml中制定的destroy-method指定的go()方法

~小Q 2006-06-06 19:56 发表评论