BlogJava-为学日益,为道日损.损之又损,以至于无为,无为而无不为.-随笔分类-『Spring 』

图解spring mvc

我一直在努力! — 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.视图对象负责渲染返回给客户端

我一直在努力! 2006-06-15 22:44 发表评论

Quartz的cron表达式

我一直在努力! — Wed, 14 Jun 2006 09:36:00 GMT

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

我一直在努力! 2006-06-14 17:36 发表评论

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

我一直在努力! — 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

我一直在努力! 2006-06-13 22:06 发表评论

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

我一直在努力! — 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
就可以了，不用改代码就可以运行第二节的例子

我一直在努力! 2006-06-13 14:02 发表评论

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

我一直在努力! — 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是多么容易啊!

我一直在努力! 2006-06-13 13:19 发表评论

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

我一直在努力! — 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的魅力啊

我一直在努力! 2006-06-12 23:15 发表评论

spring中事务的属性

我一直在努力! — 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.事务超时时间
设置了的话，事务在超过这个时间后就自动回滚。避免占用资源过久。

我一直在努力! 2006-06-11 22:50 发表评论

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

我一直在努力! — 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的事务

我一直在努力! 2006-06-10 14:02 发表评论

ProxyFactoryBean属性介绍

我一直在努力! — 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时使用

我一直在努力! 2006-06-10 11:15 发表评论

spring中基础核心接口介绍

我一直在努力! — 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.后者在属性文件修改后会重新载入

暂时介绍这几个

我一直在努力! 2006-06-09 11:56 发表评论

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

我一直在努力! — 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
对象方法调用后

我一直在努力! 2006-06-09 10:20 发表评论