BlogJava-Lilan's Blog-随笔分类-Java

实现拦截器

李岚 — Wed, 28 Dec 2005 11:02:00 GMT

摘要: 背景：拦截器是现在很多程序必须的一个东西。比如要在某个方法的前后做些处理，在一些特定的情况下可能会导致大量的重复代码。而假如我们拥有了类似拦截器一样的东西，那我们就可以任意在自己希望的方法的执行前后做我们自己的处理，比如日志，取得参数或者是事务等。实现： 1．首先定义一个业务接口 1/** *//** 3 *&nbs... 阅读全文

李岚 2005-12-28 19:02 发表评论

Spring和Webwork结合的方式

李岚 — Wed, 23 Nov 2005 05:52:00 GMT

前两种方式webwork的wiki里有，就不多说了,点这里可以查看。
而以下的给出的思路是webwork mail list的讨论的一种方案，应该是最好的一种方案。

代码1：

public class SpringContainer implements Container {
    private ApplicationContext applicationContext;

    public SpringContainer(ServletContext servletContext) {
        this.applicationContext = WebApplicationContextUtils.getWebApplicationContext(servletContext);
    }

    public SpringContainer(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    /**
     * @param key
     *            component class type or component name
     * @return @throws
     *         ComponentNotFoundException
     */
    public Object getComponent(Object key) throws ComponentNotFoundException {
        if (applicationContext == null)
            throw new IllegalStateException("Spring Application context has not been set");
        if (key == null)
            throw new ComponentNotFoundException("The component key can not be null");
        if (key instanceof Class) {
            Map beans = applicationContext.getBeansOfType((Class) key);
            if (beans == null)
                throw new ComponentNotFoundException("The container is unable to resolve single instance of " + ((Class) key).getName()
                        + ", none instances found");
            if (beans.size() == 0 || beans.size() > 1)
                throw new ComponentNotFoundException("The container is unable to resolve single instance of " + ((Class) key).getName()
                        + ", number of instances found was: " + beans.size());
            key = beans.keySet().iterator().next();
        }
        return applicationContext.getBean(key.toString());
    }

    public void reload() {
        close();
        ((AbstractApplicationContext) applicationContext).refresh();
    }

    public void autowireComponent(Object bean) {
        ((AbstractApplicationContext) applicationContext).getBeanFactory().autowireBeanProperties(bean, AutowireCapableBeanFactory.AUTOWIRE_BY_NAME, false);
    }

    public void close() {
        ((AbstractApplicationContext) applicationContext).close();
    }

}

代码2：

public class ComponentAutowireInterceptor implements Interceptor {

    public void destroy() {
        // TODO Auto-generated method stub
    }

    public void init() {
        // TODO Auto-generated method stub
    }

    public String intercept(ActionInvocation invocation) throws Exception {
        Application.getInstance().getContainer().autowireComponent(invocation.getAction());
        return invocation.invoke();
    }

}

这几段代码，你不需要在spring里配置action，也不需要在xwork.xml里面配置external-ref。只要保证action引用的东东和spring里面同名就能够auto wire by name了。

原理：拦截器会在每个action之前调用autowireComponent(invocation.getAction())。这样spring就会去自动组装这个传进来的action对象，而action对象里的属性和spring里的bean id同名。所以spring就会自动将application.xml里对应的bean注射到action的属性里去，从而达到把action按用户希望的方式组装起来的目的。

如：
appliaction.xml

    <bean id="myService">
        <property name="target">
            <bean class="myServiceDefaultImpl" autowire="byName">
          property>
    bean>

xwork.xml

        <action name="myAction" class="myAction">
            <result name="success">/success.ftlresult>
        action>

Action:

public class myAction extends ActionSupport {
    protected myService;
         .......

    }

最后记得要在web.xml配上listener-class

李岚 2005-11-23 13:52 发表评论

AOP,IOC,Spring

李岚 — Wed, 01 Jun 2005 06:11:00 GMT

理解AOP

我觉得面向对象很好地解决了软件系统中职责划分的问题.借助于面向对象,软件开发人员一般的,都可以将需求里的名词转换成系统中的对象,动词转换为对象里的方法.这样非常符合人的思维方式,非常自然.

但是,问题是某些需求却偏偏不是能用这样的”名词”和”动词”就能完美的描述出来的,假如这样的问题:需要对系统中的某些方法进行事务处理,这种需要事务代码散布在多个类中.面对这种需求,应该怎么办呢?最直接的办法就是:创建一个基类(接口)或者一个助手,将事务处理的功能放在其中,并让所有需要事务功能的类继承这个基类(接口)或者使用这个助手.加入这样的.需要修改的地方就会分散在多个文件中.这样大的修改量,无疑会增加出错的几率,并且加大系统维护的难度,如图:

因此,面向方面的编程(Aspect Oriented Programming,AOP)应运而生.AOP为开发者提供了一种描述横切关注点的机制,并能够自动将横切关注点织入到面向对象的软件系统中，从而实现了横切关注点的模块化.通过划分Aspect代码,横切关注点变得容易处理.开发者可以在编译时更改,插入或除去系统的Aspect,甚至重用系统的Aspect.” OOP只用于表示对象之间的泛化-特化(generalization-specialization)关系(通过继承来表现),而对象之间的横向关联则完全用AOP来表现. 这样,很多给对象之间横向关联增加灵活性的设计模式(例如Decorator等)将不再必要.”,如图:

Spring中的Ioc

想一想以前在使用工厂模式的时候,在最早的情况下,每个工厂可能都是一个Singleton,生成对象的代码被写死在了类里面.后来人们觉这样还是耦合程度太高,还不够灵活.所以把对象的类名写在一个XML文件里,这样一来.问题又来了,每个工厂都有自己的读取配置文件的代码,通过读取XML文件,或者通过读取Properties,工厂里充满了乱糟糟的和业务逻辑完全不相关的配置管理代码,维护起来很不方便,.而Spring通过”组件工厂”把这些都集成在了一起,用一个统一的BeanFactory来管理这些配置,而且提供了更高一级的抽象:ApplicationContext

Ioc好像很神奇的样子,其实原理和实现都很简单,就是将要使用的对象都用XML来定义,用反射来生成,用注射的方式来使用. 其实Ioc是工厂模式的升华，Ioc可以被看作是一个大工厂，只不过这个大工厂里要生成的对象都是在XML文件中给出定义的，然后利用Java的“反射”编程，根据XML中给出的类名生成相应的对象。从实现来看，Ioc是把以前在工厂方法里写死的对象生成代码，改变为由XML文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性。

Template Method和回调在框架中的使用

Template模式主要是用来解决这样的一个问题:当你知道算法的具体步骤,但不知道如何去执行这些步骤.Template把如何执行这些步骤的方法都封装成抽象的函数,并且提供一个正确的顺序去执行这些步骤,而具体子类实现这些处理各个步骤的抽象方法.

业务逻辑抽象到超类集中化就是所谓的”控制反转”了.在传统的类库中,一般是由客户端来调用类库里的方法.而在这里,却是框架控制了用户流程,具体的子类只是要求履行一个明确的契约.在Spring中的MVC框架里,jdbc包里.都大量的使用了Template模式.

而Java中的回调函数主要是在实现事件驱动模型的时候使用的,但是在Spring里面,回调被赋予了新的意义:通过回调接口(函数)来实现可扩展性.如jdbc包的RowcallbackHandler.

李岚 2005-06-01 14:11 发表评论

对Spring MVC Framework的理解

李岚 — Fri, 27 May 2005 03:29:00 GMT

摘要: 前言最近在看Spring MVC的源码,就把自己对MVC模式和对各种框架的实现的认识写出来给大家看看,算是一个总结.所以,恳请大家用怀疑的眼光来看待这篇文章,假如有认识不对的地方,麻烦指出. MVC与WEB应用 MVC是什么就不用我多说了.对于现有较成熟的Model-View-Control(MVC)框架而言,其注意的主要问题无外乎下面这些: Model: 模型应该包含由视图显示的数据... 阅读全文

李岚 2005-05-27 11:29 发表评论