结合Spring实现设计模式与面向接口编程(不断更新中...)

ahut9923

浏览: 239007 次
性别:
来自: 安徽

最近访客更多访客>>

zouchenglong

haozhihui4091

chenzhaoxie

kalcaddle

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

技术杂文

设计模式编程 Spring Bean AOP

在学设计模式的时候，遇到的一个比较大的问题就是，虽然设计模式可以解决很多的重用性、解耦和的问题，但是最后在类之间建立关系的时候，还是需要显示的编写代码，在代码修改的时候，还是需要修改比较大量的代码，现在结合Spring，设计好类结构以后，就可以进行容器外类依赖注入，这是非常好的思想，不仅在更深程度实现了解耦和，同时让程序员更关注业务，而不是实现，真正实现面向接口的编程,可以说，纯设计模式是将类关系延迟到子类，而在Spring中，我认为类关系延迟到了容器外，或者直接说延迟到了XML文件中（不仅仅是XML配置文件，还有注解），通过简单的配置文件修改，就可以修改程序整个的类依赖关系.在我们实际开发过程中，我们完全可以设计好接口的结构，完全不用管实现类，在接口设计合理后，再进行实现，那么只需要添加配置文件的内容就可以实现程序的运转

工厂模式:

我们很了解这个模式，对于面向接口编程的思想，我们只需要定义接口，然后利用Spring进行装配，实现结束以后，再将实现类的类名写入配置文件中去。

工厂模式类图

applicationContext.xml文件结构图

客户端使用代码：

                                                      view plaincopy to clipboardprint?
package org.ys.spring.factory;



import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;



public class Test {



    public static void main(String[] args) {

       ApplicationContext cs = new ClassPathXmlApplicationContext(

              "applicationContext.xml");

       IFactory bean = (IFactory) cs.getBean("factory");

       bean.createProduct().operation();

    }

}
package org.ys.spring.factory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {

ApplicationContext cs = new ClassPathXmlApplicationContext(

"applicationContext.xml");

IFactory bean = (IFactory) cs.getBean("factory");

bean.createProduct().operation();

}

如果我们需要更改工厂或者产品，我们就可以在配置文件，将红色线内的字符串进行修改就可以，完全不用修改任何代码，

单例模式:

在默认的情况下，Spring中的bean都是单例模式，只是这个单例，不是通过代码限制，而是通过Spring容器限制，也就是说如果你想通过Spring获得对象时，这个对象是单例的。

结构型模式中的组合模式

类图：

相信大家也都很熟悉这个设计模式，applicationContext.xml文件结构图：

代码如下：

类代码如下：

IComponent：

                  view plaincopy to clipboardprint?
package org.ys.spring.composite;

import java.util.List;

/**
*
* @author T-Bag.&
*
*/
public interface IComponent {

    public void operation();

    public List<IComponent> getChildren();
}
package org.ys.spring.composite;

import java.util.List;

/**
*
* @author T-Bag.&
*
*/
public interface IComponent {

public void operation();

public List<IComponent> getChildren();
}

ITreeFactory：

                 view plaincopy to clipboardprint?
package org.ys.spring.composite;

/**
*
* @author T-Bag.&
*
*/
public interface ITreeFactory {

    public IComponent getTreeRoot();
}
package org.ys.spring.composite;

/**
*
* @author T-Bag.&
*
*/
public interface ITreeFactory {

public IComponent getTreeRoot();
}

Component:

                view plaincopy to clipboardprint?
package org.ys.spring.composite.impl;

import java.util.List;

import org.ys.spring.composite.IComponent;

/**
*
* @author T-Bag.&
*
*/
public class Component implements IComponent {

    List<IComponent> list = null;

    public void setList(List<IComponent> l) {
        this.list = l;
    }

    public List<IComponent> getChildren() {
        return list;
    }

    public void operation() {

    }
}
package org.ys.spring.composite.impl;

import java.util.List;

import org.ys.spring.composite.IComponent;

/**
*
* @author T-Bag.&
*
*/
public class Component implements IComponent {

List<IComponent> list = null;

public void setList(List<IComponent> l) {
this.list = l;
}

public List<IComponent> getChildren() {
return list;
}

public void operation() {

}
}

Leaf:

                 view plaincopy to clipboardprint?
package org.ys.spring.composite.impl;

import java.util.List;

import org.ys.spring.composite.IComponent;

/**
*
* @author T-Bag.&
*
*/
public class Leaf implements IComponent {

    public List<IComponent> getChildren() {
        return null;
    }

    public void operation() {
        System.out.println("i am leaf");
    }
}
package org.ys.spring.composite.impl;

import java.util.List;

import org.ys.spring.composite.IComponent;

/**
*
* @author T-Bag.&
*
*/
public class Leaf implements IComponent {

public List<IComponent> getChildren() {
return null;
}

public void operation() {
System.out.println("i am leaf");
}
}

TreeFactory:

                view plaincopy to clipboardprint?
package org.ys.spring.composite.impl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.ys.spring.composite.IComponent;
import org.ys.spring.composite.ITreeFactory;

/**
*
* @author T-Bag.&
*
*/
public class TreeFactory implements ITreeFactory {

    public IComponent getTreeRoot() {
        ApplicationContext cs = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        return (IComponent) cs.getBean("rootnode");
    }
}
package org.ys.spring.composite.impl;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.ys.spring.composite.IComponent;
import org.ys.spring.composite.ITreeFactory;

/**
*
* @author T-Bag.&
*
*/
public class TreeFactory implements ITreeFactory {

public IComponent getTreeRoot() {
  ApplicationContext cs = new ClassPathXmlApplicationContext(
    "applicationContext.xml");
  return (IComponent) cs.getBean("rootnode");
}
}

Test:

                 view plaincopy to clipboardprint?
package org.ys.spring.composite;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

    public static void main(String[] args) {
        ApplicationContext cs = new ClassPathXmlApplicationContext(
                "applicationContext.xml");
        ITreeFactory f = (ITreeFactory) cs.getBean("factory");
        IComponent treeRoot = f.getTreeRoot();
        List<IComponent> children = treeRoot.getChildren();
        System.out.println(children == null ? false : true);
        if (children != null) {
            for (IComponent i : children) {
                i.operation();
            }
        }
    }
}
package org.ys.spring.composite;

import java.util.List;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test {

public static void main(String[] args) {
  ApplicationContext cs = new ClassPathXmlApplicationContext(
    "applicationContext.xml");
  ITreeFactory f = (ITreeFactory) cs.getBean("factory");
  IComponent treeRoot = f.getTreeRoot();
  List<IComponent> children = treeRoot.getChildren();
  System.out.println(children == null ? false : true);
  if (children != null) {
   for (IComponent i : children) {
    i.operation();
   }
  }
}
}

执行结果:

view plaincopy to clipboardprint?
true
i am leaf
true
i am leaf

桥接模式:

看过《精通Spring Java 轻量级架构开发实践》的人，可能会知道，里面有一个利用桥接设计模式设计的一个邮件发送的例子，虽然它没有直接说用什么设计模式，但是我画了一张类图，大家从这里也可以看出，不仅可以看出使用了桥接设计模式，也可以看出使用Spring的好处。

大家可以看到这是典型的桥接设计模式，更重要的是，结合这种设计模式和Spring，客户端只需要和Spring打交道，不了解具体的实现类，而且可以通过配置文件的修改，改变具体的实现类，而不用手动注入

本想将所有的设计模式使用Spring实现一遍，但发现这些设计模式都有共通点，我就介绍了几种，其他的也都是一样的设计。只需要记住，面向接口、松耦合、依赖注入.

下面这个是最基本的一些Spring配置，保留下来，以后用到Spring就可以省去一些必要的配置，方便我们编程,将配置的时候省去

view plaincopy to clipboardprint?
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context-2.5.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/tx
    http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">

    
    
    

    <context:annotation-config />
    
    
    <aop:aspectj-autoproxy />
    
    
    
    
    
    <bean id="aspectId" class="aspect class name"></bean>
    <bean id="businessBean" class="business class name"></bean>
    

    

    
    <bean id="aspectId2" class="aspect class name" />
    
    <aop:config>
        <aop:aspect id="aspectI" ref="aspectId2">
            <aop:pointcut id="pointout"
                expression="execution(* package..*.*(..))" />
            <aop:before method="切面类中的方法" pointcut-ref="pointout" />
            <aop:after-throwing method="抛出异常后执行"
                pointcut-ref="pointout" />
        </aop:aspect>
    </aop:config>

    
    <bean id="factory"
        class="org.ys.spring.composite.impl.TreeFactory">
    </bean>
    <bean id="component" class="org.ys.spring.composite.IComponent"
        factory-bean="factory" abstract="true" factory-method="getTreeRoot">
    </bean>
    <bean id="rootnode"
        class="org.ys.spring.composite.impl.Component">
        <property name="list">
            <list value-type="org.ys.spring.composite.IComponent">
                <bean class="org.ys.spring.composite.impl.Component"></bean>
                <bean class="org.ys.spring.composite.impl.Leaf"></bean>
            </list>
        </property>
    </bean>

    
    
    <bean id="dataSource"
        class="org.apache.commons.dbcp.BasicDataSource"
        destroy-method="close">
        <property name="driverClassName" value="驱动的包名加类名"></property>
        <property name="url"
            value="jdbc:mysql://localhost:8080/databaseName">
        </property>
        <property name="username" value="root"></property>
        <property name="password" value="***"></property>
        <property name="initialSize" value="10"></property>
        <property name="maxActive" value="100"></property>
        <property name="maxIdle" value="20"></property>
        <property name="minIdle" value="1"></property>
    </bean>
    
    <bean id="txManager"
        class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"></property>
    </bean>

    
    <tx:annotation-driven transaction-manager="txManager" />
    
    <bean id="dao" class="dao class impl name">
        <property name="dataSource" ref="dataSource"></property>
        
    </bean>
    
</beans>

本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/neusoftware_20063500/archive/2009/04/18/4090299.aspx

分享到：

java.sql.SQLException: 无法从套接字读取 ... | APACHE common功能列表

2011-06-20 14:21
浏览 1836
评论(0)
分类:企业架构
查看更多

发表评论

您还没有登录,请您登录后再发表评论

最近访客更多访客>>

博主相关

文章分类

社区版块

存档分类

最新评论