Spring设计模式

标签: spring 设计模式 | 发表时间:2014-03-24 18:09 | 作者:liumayulingyan
出处:http://www.iteye.com

springMVC通常采用属性注入的IOC方式和AOP织入方式相结合实现依赖注入
同时使用强制代理方式,代理类或者接口。
这里又涉及到单例模式(注入的类或者接口在容器中只存在一个)、工厂模式(通过反射实现类实例化过程的公用化)、楼上所说的装饰模式属于AOP织入的一部分。
想了解spring先从IOC和AOP开始吧。
一、单例模式案例:
一般Singleton模式通常有三种形式:
第一种形式: 也是常用的形式。
public class Singleton {
private static Singleton instance = null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
instance = new Singleton();
}
return instance;
}
}
第二种形式:
public class Singleton {
//在自己内部定义自己的一个实例,只供内部调用
private static Singleton instance = new Singleton();
private Singleton(){
//do something
}
//这里提供了一个供外部访问本class的静态方法,可以直接访问
public static Singleton getInstance(){
return instance;
}
}
第三种形式: 双重锁的形式。
public class Singleton {
private static Singleton instance = null;
private Singleton(){
//do something
}
public static Singleton getInstance(){
if(instance==null){
synchronized(Singleton.class){
if(null == instance){
instance = new Singleton();
}
}
}
return instance;
}
}//这个模式将同步内容下方到if内部,提高了执行的效率,不必每次获取对象时都进行同步,只有第一次才同步,创建了以后就没必要了。
二、IOC通过单例模式+工厂模式的实现
抽象类
Java代码 
package com.factory;   
   
import com.singleton.Singleton;   
   
public abstract class AbstractFactory {   
   
    public abstract Singleton createSingleton();   
}  
工厂类
Java代码 
package com.factory;   
   
import com.singleton.Singleton;   
   
public class Factory extends AbstractFactory{   
   
    @Override  
    public Singleton createSingleton() {   
        return Singleton.getInstance();   
    }   
   
}  
单例类
Java代码 
package com.singleton;   
   
public class Singleton {   
   
    private static Singleton instance = null;   
        
    public Singleton(){   
            
    }   
        
    public static synchronized Singleton getInstance(){   
        if(instance == null){   
            instance = new Singleton();   
        }   
        return instance;   
    }   
        
    public String testSingleton(){   
        return "Hello Singleton";   
    }   
}  
测试类
Java代码 
package com.test;     
import com.factory.Factory;   
import com.singleton.Singleton;   
public class Test {        
    public static void main(String[] args){   
        Factory factory = new Factory();   
        Singleton s = factory.createSingleton();   
        System.out.print(s.testSingleton());   
    }   
} 
三、代理案例
1.定义提供方法的接口
public interface IHello {
       
       public void hello(String name);
}
2.接口实现类
public class HelloSpeaker implements IHello {
  
       public void hello(String name) {
             
            System. out.println("实现类中的hello():" +"Hello " + name);
             
      }
}
3.定义静态代理类注入接口通过实现类实现方法
public class HelloProxy implements IHello {
       private IHello iHello ;
       public HelloProxy(IHello iHello) {
             super();
             this.iHello = iHello;
      }
       public void hello(String name) {
            System. out.println("代理类中的hello():" );
             iHello.hello(name);
      }
}
4.静态代理类测试main方法入口
public class ProxyDemo {
       public static void main(String[] args) {
             
            IHello iHello = new HelloProxy(new HelloSpeaker());
             
            iHello. hello("long");
             
      }
}
5.定义动态代理类减少代理类对接口的依赖
public class LogHandler implements InvocationHandler {
       private Object implClass ;
       public Object bind(Object implClass) {
             
             this.implClass = implClass;
             
             return Proxy.newProxyInstance(implClass.getClass().getClassLoader(),
                        implClass.getClass().getInterfaces(), this);
             
      }
       /**
       * 代理对象,这里面还可以改变原有的方法
       */
       public Object invoke(Object proxy, Method method, Object[] args)
                   throws Throwable {
            Object result = null;
             try {
                  System. out.println("添加日志" );
                  result = method.invoke( implClass, args);
            } catch (Exception e) {
                  e.printStackTrace();
            }
             return null ;
      }
}
6.动态代理类的测试主入口
public class ProxyDt {
       public static void main(String[] args) { 
             
           LogHandler logHandler = new LogHandler(); 
           IHello iHello = (IHello) logHandler.bind( new HelloSpeaker()); 
           iHello.hello( "long"); 
         
           }
}
四、利用ProxyFactory连接CGLIB简单实现AOP: 
加入包aopalliance.jar\cglib-nodep-2.1_3.jar demo:
view plaincopy to clipboardprint?
package cn.partner4java.proxy.proxyfactory;  
   
/** 
* 被代理的对象 
* @author partner4java 
* 
*/  
public class MessageWriter {  
    public void writeMessage(){  
        System.out.println("world!");  
    }  
}  
package cn.partner4java.proxy.proxyfactory;  
   
import org.aopalliance.intercept.MethodInterceptor;  
import org.aopalliance.intercept.MethodInvocation;  
   
/** 
* 装饰者 
* MethodInterceptor接口是对方法调用连接点实现包围通知的AOP联盟标准接口 
* @author partner4java 
* 
*/  
public class MessageDecorator implements MethodInterceptor{  
   
    public Object invoke(MethodInvocation invocation) throws Throwable {  
        System.out.print("Hello ");  
        Object retVal = invocation.proceed();  
        return retVal;  
    }  
   
}  
package cn.partner4java.proxy.proxyfactory;  
   
import org.springframework.aop.framework.ProxyFactory;  
   
/** 
* 调用组装 
* 这里最重要的部分是我们使用ProxyFactory来创建一个目标对象代理,同时织入通知  
* @author partner4java 
* 
*/  
public class HelloWorldWeaver {  
   
    public static void main(String[] args) {  
        //目标  
        MessageWriter target = new MessageWriter();  
           
        //create the proxy  
        ProxyFactory proxyFactory = new ProxyFactory();  
           
        proxyFactory.addAdvice(new MessageDecorator());  
        proxyFactory.setTarget(target);  
           
        //获取返回被代理的目标  
        MessageWriter proxy = (MessageWriter) proxyFactory.getProxy();  
           
        target.writeMessage();  
        System.out.println("---");  
        proxy.writeMessage();  
//      后台打印:  
//      world!  
//      ---  
//      Hello world!  
    }  
   
}


已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [spring 设计模式] 推荐:

Spring设计模式

- - 行业应用 - ITeye博客
springMVC通常采用属性注入的IOC方式和AOP织入方式相结合实现依赖注入 同时使用强制代理方式,代理类或者接口. 这里又涉及到单例模式(注入的类或者接口在容器中只存在一个)、工厂模式(通过反射实现类实例化过程的公用化)、楼上所说的装饰模式属于AOP织入的一部分. 想了解spring先从IOC和AOP开始吧.

深入解析spring中用到的九种设计模式

- - 编程语言 - ITeye博客
转载请注明出处,文章首发于. 设计模式作为工作学习中的枕边书,却时常处于勤说不用的尴尬境地,也不是我们时常忘记,只是一直没有记忆. 今天,螃蟹在IT学习者网站就设计模式的内在价值做一番探讨,并以spring为例进行讲解,只有领略了其设计的思想理念,才能在工作学习中运用到“无形”. Spring作为业界的经典框架,无论是在架构设计方面,还是在代码编写方面,都堪称行内典范.

Scala设计模式

- - ITeye博客
       我的话: 在国外网站上看到一篇文章,里面详细描述了很多设计模式,并且用Java及Scala两种语言描述,清晰的让我们看到各种常规的设计模式,在Scala中是如何在语言特性层面直接支持的. 基于文章很nice,我利用今天的空闲时间将其翻译,希望大家能一起学习,讨论. 翻译比较倡促,也就两小时左右,有何不当,请在下面留言指出.

“另类” 设计模式

- Sean Lee - 酷壳 - CoolShell.cn
下面这篇文章来自这里:http://www.lsd.ic.unicamp.br/~oliva/fun/prog/resign-patterns,这篇文章有点意思了,山寨了我们著名的Design Pattern. 这篇文章并不是很容易翻译,也许我翻译的不好,大家多指正. 另外,这篇文章将失去原有的趣味在于其使用了经典设计模式的单词很相似的单词,一走眼你还以为是正二八经的设计模式.

【译】屏幕设计模式

- 志强 - 所有文章 - UCD大社区
模式是广泛适用的解决一般问题的解决方案. 在开发应用程序过程中,无论是面对抽象还是实际问题,模式都大有用处. 而标准屏幕模式对于优秀的Web程序甚至企业级软件都很有帮助. 摘要/细节(Master/Detail). 摘要/细节模式可横向也可竖向. 该模式是满足用户既停留在一个页面又可浏览多个条目需求的典范.

设计模式之代理模式(Proxy)

- - 博客园_首页
这段时间一直忙于期末考试,好久没来博客园了,现在好了,终于考完了,也该过上正常的日子了. 开学就是大四的学生了,时间过的可是真快啊,转眼间大学四年已经接近尾声了. 回想大学这三年,成绩还可以吧(年级前10%),参加过各种竞赛(acm,数学建模等等),学生会也呆过(打了一年的酱油),好哥们也有那么五六个(希望以后能在一个城市发展,大学期间的宝贵财富啊),另外所谓的大学生创新实践项目也搞了一个(就算开阔一下视野吧,大学能生有什么创新呢.

设计模式原则总结

- - IT技术博客大学习
0、单一职责原则(SRP) 就一个类而言,应该仅有一个引起它变化的原因. 一、”开放-封闭”原则(OCP) 在软件设计模式中,这种不能修改,但可以扩展的思想也是最重要的一种设计原则. 即软件实体(类、模板、函数等等)应该可以扩展,但是不可修改. 【通俗】:设计的时候,时刻考虑,尽量让这个类是足够好,写好了就不要去修改了,如果新需求来,我们增加一些类就完事了,原来的代码能不动则不动.

Web应用的缓存设计模式

- - robbin的自言自语
从10年前的2003年开始,在Web应用领域,ORM(对象-关系映射)框架就开始逐渐普及,并且流行开来,其中最广为人知的就是Java的开源ORM框架Hibernate,后来Hibernate也成为了EJB3的实现框架;2005年以后,ORM开始普及到其他编程语言领域,其中最有名气的是Ruby on rails框架的ORM - ActiveRecord.

设计模式和设计原则

- - 编程 - 编程语言 - ITeye博客
26.1  设计模式和设计原则. 26.1.1  设计模式和设计原则的关系. 面向对象的分析设计有很多原则,这些原则大都从思想层面,给我们指出了面向对象分析设计的正确方向,是我们进行面向对象分析设计应该尽力遵守的准则.        而设计模式已经是针对某个场景下某些问题的某个解决方案. 也就是说这些设计原则是思想上的指导,而设计模式是实现上的手段,因此设计模式也是应该遵守这些原则的,换句话说,设计模式就是这些设计原则的一些具体体现.

Spring详解

- - CSDN博客架构设计推荐文章
Spring是一个开源的控制反转(Inversion of Control ,IoC)和面向切面(AOP)的容器框架.它的主要目的是简化企业开发.. PersonDaoBean 是在应用内部创建及维护的. 所谓控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的.